Merge lp:~mir-team/mir/trunk-0.1.5 into lp:mir/0.1

[kevin gunn]

Latest upstream release of Mir0.1.5 (lp:~mir-team/mir/development-branch r1377)
plus upcoming enhancement:
   https://code.launchpad.net/~alan-griffiths/mir/fix-1276704/+merge/205357

.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1177
http://jenkins.qa.ubuntu.com/job/mir-ci/1635/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/848
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/845
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/33
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/33/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/33
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/33/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I figured out what this branch is composed of and it's not r1372...

1. Start with dev r1377, but there's still about 1000 lines different.
2. Manually patch in https://code.launchpad.net/~alan-griffiths/mir/fix-1276704/+merge/205357
3. Add an unexplained change to debian/rules
4. debian/changelog additions.

I think we need to do this more cleanly so we know what's actually going in to the merge. Otherwise there's no accurate historical log of what has changed and why.

I suggest starting dropping #2 and proposing it separately, directly to lp:mir with the trunk-0.15 branch as prereq. Unless it lands in development-branch beforehand, which would be cleaner. I also would like to know where #3 (debian/rules change) has come from, and some documentation of that change.

It would reflect badly on mir-team if we review changes to development-branch carefully, but don't do the same for lp:mir and let in undocumented changes.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

BTW, if Ubuntu is desperate for it then you can always merge fix-1276704 directly to lp:mir without review. But it could become a major conflict headache if we find it needs fixing before it hits development-branch. So best to let it land in development-branch first.

[Daniel van Vugt (vanvugt)]

Oooh, the mysterious debian/rules change #3 comes from the destination lp:mir. We'll have to revisit that...

I'll track issue #2 manually in LP and do an upstream Mir 0.1.5 release from r1377 to keep things as consistent as possible. So approved!

review: Approve

[Daniel van Vugt (vanvugt)]

I've made major enhancements to the changelog text. Needs review again.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1178
http://jenkins.qa.ubuntu.com/job/mir-ci/1636/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/853
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/850
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/34
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/34/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/34
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/34/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1181
http://jenkins.qa.ubuntu.com/job/mir-ci/1637/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/861
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/858
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/35
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/35/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/35
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/35/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[kevin gunn (kgunn72)]

thanks for the clean up, looks good (i see now how you want to handle tag vs promotion)

review: Approve

[Kevin DuBois (kdub)]

Please make sure not to pick up rev1383 because it contains a nexus 10 bug: https://bugs.launchpad.net/mir/+bug/1278658. (this has a fix, up for review)

[Kevin DuBois (kdub)]

> Please make sure not to pick up rev1383 because it contains a nexus 10 bug:
> https://bugs.launchpad.net/mir/+bug/1278658. (this has a fix, up for review)

fixed in lp:mir/devel rev 1388

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-01-22 08:32:55 +0000
+++ CMakeLists.txt	2014-02-10 09:00:06 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 1)
-set(MIR_VERSION_PATCH 4)
+set(MIR_VERSION_PATCH 5)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 

=== modified file 'debian/changelog'
--- debian/changelog	2014-02-04 14:49:07 +0000
+++ debian/changelog	2014-02-10 09:00:06 +0000
@@ -1,3 +1,52 @@
+mir (0.1.5-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Cherry-picked from future release 0.1.6:
+    - frontend, shell: provide the client process ID in the shell::Session
+      interface (LP: #1276704)
+  * New upstream release 0.1.5 (https://launchpad.net/mir/+milestone/0.1.5)
+    - mirclient ABI bumped to 7
+    - mirserver ABI bumped to 15
+    - Refactoring to support client-controled RPC.
+    - Add an translucent server example (use sparingly, this will kill
+      performance!)
+    - Add workaround for Qualcomm Snapdragon 8960 driver bug.
+    - android-input: Improve debug output
+    - Screen rotation support half done (rotation of the screen works but input
+      rotation not implemented yet).
+    - Add groundwork for overlay support to take better advantage of mobile
+      hardware features and optimize composition in future.
+    - Add support for HWC 1.2 (Android 4.4)
+    - Add groundwork for screencasting (screen recording).
+    - Optimized surface resizing, significantly reducing event flooding for
+      some input configurations like touch.
+    - Bugs fixed:
+      . Surfaces no longer visible at all on Nexus 10 (LP: #1271853)
+      . mir nested server failure: what(): error binding buffer to texture
+        (LP: #1272041)
+      . Unity does not process events from evdev device created before unity is
+        restarted (autopilot tests) (LP: #1238417)
+      . mir_unit_tests can't run on touch images any more (missing
+        libumockdev.so.0) (LP: #1271434)
+      . chmod 777 /tmp/mir_socket is no longer sufficient for non-root clients
+        to connect to a root server (LP: #1272143)
+      . Nexus7(2013) flo framerate maxes out at 30fps (LP: #1274189)
+      . libmirserver user is unable to #include
+         <mir/frontend/template_protobuf_message_processor.h> (LP: #1276162)
+      . libmirclient user cannot "#include <mir/client/private.h>"
+        (LP: #1276565)
+      . AndroidInternalClient.internal_client_creation_and_use hangs on Nexus
+        10 (LP: #1270685)
+      . Tests that use the InProcessServer bind the default socket file
+        (LP: #1271604)
+      . BasicConnector threads exit immediately (LP: #1271655)
+      . Integration tests TestClientIPCRender.test_accelerated_render fails on
+        Galaxy Nexus and Nexus4 (LP: #1272597)
+      . Android backend unit-tests FTBS on amd64 (LP: #1276621)
+      . Erroneous use of last_consumed in SwitchingBundle::compositor_acquire
+        (LP: #1270964)
+
+ -- Kevin Gunn <[e-mail]>  Thu, 06 Feb 2014 10:54:17 -0600
+
 mir (0.1.4+14.04.20140204-0ubuntu1) trusty; urgency=medium
 
   [ Daniel van Vugt ]

=== modified file 'debian/control'
--- debian/control	2014-01-23 08:21:21 +0000
+++ debian/control	2014-02-10 09:00:06 +0000
@@ -70,7 +70,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver14
+Package: libmirserver15
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -116,7 +116,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver14 (= ${binary:Version}),
+Depends: libmirserver15 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,
@@ -128,7 +128,7 @@
  .
  Contains header files required to build Mir servers.
 
-Package: libmirclient6
+Package: libmirclient7
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -146,7 +146,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirclient6 (= ${binary:Version}),
+Depends: libmirclient7 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          ${misc:Depends},

=== renamed file 'debian/libmirclient6.install' => 'debian/libmirclient7.install'
--- debian/libmirclient6.install	2014-01-17 06:22:01 +0000
+++ debian/libmirclient7.install	2014-02-10 09:00:06 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirclient.so.6
+usr/lib/*/libmirclient.so.7

=== renamed file 'debian/libmirserver14.install' => 'debian/libmirserver15.install'
--- debian/libmirserver14.install	2014-01-17 06:22:01 +0000
+++ debian/libmirserver15.install	2014-02-10 09:00:06 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.14
+usr/lib/*/libmirserver.so.15

=== modified file 'debian/mir-utils.install'
--- debian/mir-utils.install	2014-01-10 05:48:41 +0000
+++ debian/mir-utils.install	2014-02-10 09:00:06 +0000
@@ -1,2 +1,3 @@
 usr/bin/mirping
 usr/bin/mirout
+usr/bin/mirscreencast

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-01-13 06:12:33 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -41,6 +41,8 @@
 
 #include <xkbcommon/xkbcommon-keysyms.h>
 
+#include <unistd.h>
+
 #include <functional>
 
 #include <assert.h>
@@ -93,7 +95,7 @@
         .of_size(surface_size)
         .of_buffer_usage(mg::BufferUsage::hardware)
         .of_pixel_format(mir_pixel_format_argb_8888);
-    auto session = shell->open_session("Inprocess client", std::make_shared<NullEventSink>());
+    auto session = shell->open_session(getpid(), "Inprocess client", std::make_shared<NullEventSink>());
     // TODO: Why do we get an ID? ~racarr
     auto surface = session->get_surface(shell->create_surface_for(session, params));
 

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2014-01-29 12:51:30 +0000
+++ examples/render_surfaces.cpp	2014-02-10 09:00:06 +0000
@@ -419,8 +419,9 @@
              */
             {
                 mg::Buffer* buffer{nullptr};
-                s->swap_buffers(buffer);
-                s->swap_buffers(buffer);
+                auto const complete = [&](mg::Buffer* new_buf){ buffer = new_buf; };
+                s->swap_buffers(buffer, complete);
+                s->swap_buffers(buffer, complete);
             }
 
             /*

=== modified file 'include/platform/mir/graphics/display.h'
--- include/platform/mir/graphics/display.h	2013-08-28 03:41:48 +0000
+++ include/platform/mir/graphics/display.h	2014-02-10 09:00:06 +0000
@@ -50,9 +50,9 @@
     virtual void for_each_display_buffer(std::function<void(DisplayBuffer&)> const& f) = 0;
 
     /**
-     * Gets the current output configuration.
+     * Gets a copy of the current output configuration.
      */
-    virtual std::shared_ptr<DisplayConfiguration> configuration() = 0;
+    virtual std::unique_ptr<DisplayConfiguration> configuration() const = 0;
 
     /**
      * Sets a new output configuration.

=== modified file 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/compositor/buffer_stream.h	2014-01-13 06:12:33 +0000
+++ include/server/mir/compositor/buffer_stream.h	2014-02-10 09:00:06 +0000
@@ -41,7 +41,7 @@
 public:
     virtual ~BufferStream() = default;
 
-    virtual void swap_client_buffers(graphics::Buffer*& buffer) = 0;
+    virtual void swap_client_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) = 0;
     virtual std::shared_ptr<graphics::Buffer>
         lock_compositor_buffer(unsigned long frameno) = 0;
     virtual std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() = 0;

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-01-27 17:47:06 +0000
+++ include/server/mir/default_server_configuration.h	2014-02-10 09:00:06 +0000
@@ -50,6 +50,7 @@
 class SessionAuthorizer;
 class EventSink;
 class DisplayChanger;
+class Screencast;
 }
 
 namespace shell
@@ -171,6 +172,7 @@
     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();
+    virtual std::shared_ptr<frontend::Screencast>             the_screencast();
     /** @name frontend configuration - internal dependencies
      * internal dependencies of frontend
      *  @{ */
@@ -266,6 +268,7 @@
     CachedPtr<frontend::SessionAuthorizer> session_authorizer;
     CachedPtr<frontend::EventSink> global_event_sink;
     CachedPtr<frontend::SessionCreator>    session_creator;
+    CachedPtr<frontend::Screencast> screencast;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
     CachedPtr<scene::SurfaceStack> surface_stack;

=== modified file 'include/server/mir/frontend/message_processor.h'
--- include/server/mir/frontend/message_processor.h	2014-01-22 15:54:11 +0000
+++ include/server/mir/frontend/message_processor.h	2014-02-10 09:00:06 +0000
@@ -19,6 +19,8 @@
 #ifndef MIR_FRONTEND_MESSAGE_PROCESSOR_H_
 #define MIR_FRONTEND_MESSAGE_PROCESSOR_H_
 
+#include <google/protobuf/service.h>
+
 namespace mir
 {
 namespace protobuf
@@ -32,11 +34,23 @@
 {
 namespace detail
 {
+class Invocation
+{
+public:
+    Invocation(mir::protobuf::wire::Invocation const& invocation) :
+        invocation(invocation) {}
+
+    const ::std::string& method_name() const;
+    const ::std::string& parameters() const;
+    ::google::protobuf::uint32 id() const;
+private:
+    mir::protobuf::wire::Invocation const& invocation;
+};
 
 class MessageProcessor
 {
 public:
-    virtual bool dispatch(mir::protobuf::wire::Invocation const& invocation) = 0;
+    virtual bool dispatch(Invocation const& invocation) = 0;
 
 protected:
     MessageProcessor() = default;

=== added file 'include/server/mir/frontend/screencast.h'
--- include/server/mir/frontend/screencast.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/frontend/screencast.h	2014-02-10 09:00:06 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_FRONTEND_SCREENCAST_H_
+#define MIR_FRONTEND_SCREENCAST_H_
+
+#include "mir/int_wrapper.h"
+#include "mir/graphics/display_configuration.h"
+
+#include <memory>
+
+namespace mir
+{
+namespace graphics { class Buffer; }
+namespace frontend
+{
+namespace detail { struct ScreencastSessionIdTag; }
+
+typedef IntWrapper<detail::ScreencastSessionIdTag,uint32_t> ScreencastSessionId;
+
+class Screencast
+{
+public:
+    virtual ~Screencast() = default;
+
+    virtual ScreencastSessionId create_session(
+        graphics::DisplayConfigurationOutputId output_id) = 0;
+    virtual void destroy_session(ScreencastSessionId id) = 0;
+    virtual std::shared_ptr<graphics::Buffer> capture(ScreencastSessionId id) = 0;
+
+protected:
+    Screencast() = default;
+    Screencast(Screencast const&) = delete;
+    Screencast& operator=(Screencast const&) = delete;
+};
+
+}
+}
+
+#endif /* MIR_FRONTEND_SCREENCAST_H_ */

=== modified file 'include/server/mir/frontend/shell.h'
--- include/server/mir/frontend/shell.h	2014-01-13 06:12:33 +0000
+++ include/server/mir/frontend/shell.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -20,6 +20,9 @@
 #define MIR_FRONTEND_SHELL_H_
 
 #include "mir/frontend/surface_id.h"
+
+#include <sys/types.h>
+
 #include <memory>
 
 namespace mir
@@ -39,7 +42,10 @@
     virtual ~Shell() = default;
 
     virtual std::shared_ptr<Session> open_session(
-        std::string const& name, std::shared_ptr<EventSink> const& sink) = 0;
+        pid_t client_pid,
+        std::string const& name,
+        std::shared_ptr<EventSink> const& sink) = 0;
+
     virtual void close_session(std::shared_ptr<Session> const& session)  = 0;
 
     virtual SurfaceId create_surface_for(std::shared_ptr<Session> const& session,

=== modified file 'include/server/mir/frontend/surface.h'
--- include/server/mir/frontend/surface.h	2014-01-13 06:12:33 +0000
+++ include/server/mir/frontend/surface.h	2014-02-10 09:00:06 +0000
@@ -56,13 +56,20 @@
     virtual geometry::Size size() const = 0;
     virtual MirPixelFormat pixel_format() const = 0;
 
-    virtual void swap_buffers(graphics::Buffer*&) = 0;
+    virtual void swap_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) = 0;
 
     virtual bool supports_input() const = 0;
     virtual int client_input_fd() const = 0;
 
     virtual int configure(MirSurfaceAttrib attrib, int value) = 0;
 
+    /**
+     *  swap_buffers_blocking() is a convenience wrapper around swap_buffers()
+     *  it forces the current thread to block until complete() is called.
+     *  Use with care!
+     */
+    void swap_buffers_blocking(graphics::Buffer*& buffer);
+
 protected:
     Surface() = default;
     Surface(Surface const&) = delete;

=== modified file 'include/server/mir/frontend/template_protobuf_message_processor.h'
--- include/server/mir/frontend/template_protobuf_message_processor.h	2014-01-21 12:49:00 +0000
+++ include/server/mir/frontend/template_protobuf_message_processor.h	2014-02-10 09:00:06 +0000
@@ -22,8 +22,6 @@
 
 #include "mir/frontend/message_processor.h"
 
-#include "mir_protobuf_wire.pb.h"
-
 #include <google/protobuf/service.h>
 
 #include <boost/exception/diagnostic_information.hpp>
@@ -54,7 +52,7 @@
         const ParameterMessage* request,
         ResultMessage* response,
         ::google::protobuf::Closure* done),
-    mir::protobuf::wire::Invocation const& invocation)
+        Invocation const& invocation)
 {
     ParameterMessage parameter_message;
     parameter_message.ParseFromString(invocation.parameters());

=== modified file 'include/server/mir/shell/session.h'
--- include/server/mir/shell/session.h	2014-01-13 06:12:33 +0000
+++ include/server/mir/shell/session.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -7,11 +7,11 @@
  *
  * 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
+ * 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/>.
+ * along with this program.   If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored By: Robert Carr <[e-mail]>
  */
@@ -22,9 +22,10 @@
 #include "mir/frontend/session.h"
 #include "mir/shell/snapshot.h"
 
+#include <sys/types.h>
+
 namespace mir
 {
-
 namespace shell
 {
 class Surface;
@@ -34,12 +35,12 @@
 public:
     virtual std::string name() const = 0;
     virtual void force_requests_to_complete() = 0;
+    virtual pid_t process_id() const = 0;
 
     virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
     virtual std::shared_ptr<Surface> default_surface() const = 0;
     virtual void set_lifecycle_state(MirLifecycleState state) = 0;
 };
-
 }
 }
 

=== modified file 'include/shared/mir/int_wrapper.h'
--- include/shared/mir/int_wrapper.h	2013-08-28 03:41:48 +0000
+++ include/shared/mir/int_wrapper.h	2014-02-10 09:00:06 +0000
@@ -23,12 +23,10 @@
 
 namespace mir
 {
-template<typename Tag>
+template<typename Tag, typename ValueType=int>
 class IntWrapper
 {
 public:
-    typedef int ValueType;
-
     IntWrapper() : value(0) {}
 
     explicit IntWrapper(ValueType value) : value(value) {}
@@ -38,39 +36,39 @@
     ValueType value;
 };
 
-template<typename Tag>
-std::ostream& operator<<(std::ostream& out, IntWrapper<Tag> const& value)
+template<typename Tag, typename ValueType>
+std::ostream& operator<<(std::ostream& out, IntWrapper<Tag,ValueType> const& value)
 {
     out << value.as_value();
     return out;
 }
 
-template<typename Tag>
-inline bool operator == (IntWrapper<Tag> const& lhs, IntWrapper<Tag> const& rhs)
+template<typename Tag, typename ValueType>
+inline bool operator == (IntWrapper<Tag,ValueType> const& lhs, IntWrapper<Tag,ValueType> const& rhs)
 {
     return lhs.as_value() == rhs.as_value();
 }
 
-template<typename Tag>
-inline bool operator != (IntWrapper<Tag> const& lhs, IntWrapper<Tag> const& rhs)
+template<typename Tag, typename ValueType>
+inline bool operator != (IntWrapper<Tag,ValueType> const& lhs, IntWrapper<Tag,ValueType> const& rhs)
 {
     return lhs.as_value() != rhs.as_value();
 }
 
-template<typename Tag>
-inline bool operator <= (IntWrapper<Tag> const& lhs, IntWrapper<Tag> const& rhs)
+template<typename Tag, typename ValueType>
+inline bool operator <= (IntWrapper<Tag,ValueType> const& lhs, IntWrapper<Tag,ValueType> const& rhs)
 {
     return lhs.as_value() <= rhs.as_value();
 }
 
-template<typename Tag>
-inline bool operator >= (IntWrapper<Tag> const& lhs, IntWrapper<Tag> const& rhs)
+template<typename Tag, typename ValueType>
+inline bool operator >= (IntWrapper<Tag,ValueType> const& lhs, IntWrapper<Tag,ValueType> const& rhs)
 {
     return lhs.as_value() >= rhs.as_value();
 }
 
-template<typename Tag>
-inline bool operator < (IntWrapper<Tag> const& lhs, IntWrapper<Tag> const& rhs)
+template<typename Tag, typename ValueType>
+inline bool operator < (IntWrapper<Tag,ValueType> const& lhs, IntWrapper<Tag,ValueType> const& rhs)
 {
     return lhs.as_value() < rhs.as_value();
 }
@@ -79,11 +77,11 @@
 #include <functional>
 namespace std
 {
-template<typename Tag>
-struct hash< ::mir::IntWrapper<Tag> >
+template<typename Tag, typename ValueType>
+struct hash< ::mir::IntWrapper<Tag,ValueType> >
 {
     std::hash<int> self;
-    std::size_t operator()(::mir::IntWrapper<Tag> const& id) const
+    std::size_t operator()(::mir::IntWrapper<Tag,ValueType> const& id) const
     {
         return self(id.as_value());
     }

=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2014-02-10 09:00:06 +0000
@@ -37,7 +37,7 @@
     ~MockBufferBundle() noexcept
     {}
 
-    MOCK_METHOD0(client_acquire,     graphics::Buffer*());
+    MOCK_METHOD1(client_acquire,     void(std::function<void(graphics::Buffer*)>));
     MOCK_METHOD1(client_release,     void(graphics::Buffer*));
     MOCK_METHOD1(compositor_acquire, std::shared_ptr<graphics::Buffer>(unsigned long));
     MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));

=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2014-02-10 09:00:06 +0000
@@ -31,7 +31,7 @@
 {
 struct MockBufferStream : public compositor::BufferStream
 {
-    MOCK_METHOD1(swap_client_buffers, void(graphics::Buffer*&));
+    MOCK_METHOD2(swap_client_buffers, void(graphics::Buffer*, std::function<void(graphics::Buffer*)> completee));
     MOCK_METHOD1(lock_compositor_buffer,
                  std::shared_ptr<graphics::Buffer>(unsigned long));
     MOCK_METHOD0(lock_snapshot_buffer, std::shared_ptr<graphics::Buffer>());

=== modified file 'include/test/mir_test_doubles/mock_display.h'
--- include/test/mir_test_doubles/mock_display.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_display.h	2014-02-10 09:00:06 +0000
@@ -36,7 +36,7 @@
 {
 public:
     MOCK_METHOD1(for_each_display_buffer, void (std::function<void(graphics::DisplayBuffer&)> const&));
-    MOCK_METHOD0(configuration, std::shared_ptr<graphics::DisplayConfiguration>());
+    MOCK_CONST_METHOD0(configuration, std::unique_ptr<graphics::DisplayConfiguration>());
     MOCK_METHOD1(configure, void(graphics::DisplayConfiguration const&));
     MOCK_METHOD2(register_configuration_change_handler,
                  void(graphics::EventHandlerRegister&, graphics::DisplayConfigurationChangeHandler const&));

=== modified file 'include/test/mir_test_doubles/mock_fb_hal_device.h'
--- include/test/mir_test_doubles/mock_fb_hal_device.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/mock_fb_hal_device.h	2014-02-10 09:00:06 +0000
@@ -37,7 +37,7 @@
     MockFBHalDevice(unsigned int const width, unsigned int const height,
                     int const pf, int const numfbs)
         : framebuffer_device_t({
-            empty_module,
+            hw_device_t(),
             0,
             width,
             height,
@@ -86,8 +86,6 @@
     MOCK_METHOD2(enableScreen_interface, int(struct framebuffer_device_t*, int));
     MOCK_METHOD2(post_interface, int(struct framebuffer_device_t*, buffer_handle_t));
     MOCK_METHOD2(setSwapInterval_interface, int(struct framebuffer_device_t*, int));
-
-    hw_device_t empty_module;
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_frontend_surface.h'
--- include/test/mir_test_doubles/mock_frontend_surface.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/mock_frontend_surface.h	2014-02-10 09:00:06 +0000
@@ -39,7 +39,7 @@
 
     MOCK_METHOD0(destroy, void());
     MOCK_METHOD0(force_requests_to_complete, void());
-    MOCK_METHOD1(swap_buffers, void(graphics::Buffer*&));
+    MOCK_METHOD2(swap_buffers, void(graphics::Buffer*, std::function<void(graphics::Buffer*)> complete));
 
     MOCK_CONST_METHOD0(size, geometry::Size());
     MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());

=== modified file 'include/test/mir_test_doubles/mock_hwc_composer_device_1.h'
--- include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2014-01-23 17:26:51 +0000
+++ include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2014-02-10 09:00:06 +0000
@@ -76,6 +76,11 @@
         fb_fence = fence;
     }
 
+    void hwc_set_retire_fence(int fence)
+    {
+        retire_fence = fence;
+    }
+
     int save_last_prepare_arguments(struct hwc_composer_device_1 *, size_t size, hwc_display_contents_1_t** displays)
     {
         if ((size == 0) || (!displays)) 
@@ -122,12 +127,14 @@
                     set_layerlist.back().visibleRegionScreen = {0, nullptr};
                 }
 
+                save_args(&display0_set_content, displays);
+
                 if (displays[0]->numHwLayers >= 2)
                 {
                     displays[0]->hwLayers[1].releaseFenceFd = fb_fence;
+                    displays[0]->retireFenceFd = retire_fence;
                 }
 
-                save_args(&display0_set_content, displays);
             default:
                 break;
         }
@@ -186,6 +193,7 @@
     std::vector<hwc_layer_1> prepare_layerlist;
     hwc_display_contents_1_t display0_prepare_content;
     int fb_fence;
+    int retire_fence;
 };
 
 }

=== added file 'include/test/mir_test_doubles/mock_screencast.h'
--- include/test/mir_test_doubles/mock_screencast.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_screencast.h	2014-02-10 09:00:06 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_SCREENCAST_H_
+#define MIR_TEST_DOUBLES_MOCK_SCREENCAST_H_
+
+#include "mir/frontend/screencast.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class MockScreencast : public frontend::Screencast
+{
+public:
+    MOCK_METHOD1(create_session,
+                 frontend::ScreencastSessionId(
+                     graphics::DisplayConfigurationOutputId));
+    MOCK_METHOD1(destroy_session, void(frontend::ScreencastSessionId));
+    MOCK_METHOD1(capture,
+                 std::shared_ptr<graphics::Buffer>(
+                     frontend::ScreencastSessionId));
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_SCREENCAST_H_ */
+

=== modified file 'include/test/mir_test_doubles/mock_shell.h'
--- include/test/mir_test_doubles/mock_shell.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_shell.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -34,8 +34,11 @@
 
 struct MockShell : public frontend::Shell
 {
-    MOCK_METHOD2(open_session, std::shared_ptr<frontend::Session>(
-        std::string const&, std::shared_ptr<frontend::EventSink> const&));
+    MOCK_METHOD3(open_session, std::shared_ptr<frontend::Session>(
+        pid_t client_pid,
+        std::string const&,
+        std::shared_ptr<frontend::EventSink> const&));
+
     MOCK_METHOD1(close_session, void(std::shared_ptr<frontend::Session> const&));
 
     MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, shell::SurfaceCreationParameters const&));

=== modified file 'include/test/mir_test_doubles/mock_shell_session.h'
--- include/test/mir_test_doubles/mock_shell_session.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/mock_shell_session.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -42,6 +42,7 @@
     MOCK_CONST_METHOD0(default_surface, std::shared_ptr<shell::Surface>());
 
     MOCK_CONST_METHOD0(name, std::string());
+    MOCK_CONST_METHOD0(process_id, pid_t());
     MOCK_METHOD0(force_requests_to_complete, void());
 
     MOCK_METHOD0(hide, void());

=== modified file 'include/test/mir_test_doubles/null_display.h'
--- include/test/mir_test_doubles/null_display.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/null_display.h	2014-02-10 09:00:06 +0000
@@ -39,9 +39,11 @@
         /* yield() is needed to ensure reasonable runtime under valgrind for some tests */
         std::this_thread::yield();
     }
-    std::shared_ptr<graphics::DisplayConfiguration> configuration()
+    std::unique_ptr<graphics::DisplayConfiguration> configuration() const override
     {
-        return std::make_shared<NullDisplayConfiguration>();
+        return std::unique_ptr<graphics::DisplayConfiguration>(
+            new NullDisplayConfiguration
+        );
     }
     void configure(graphics::DisplayConfiguration const&) {}
     void register_configuration_change_handler(

=== added file 'include/test/mir_test_doubles/null_screencast.h'
--- include/test/mir_test_doubles/null_screencast.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_screencast.h	2014-02-10 09:00:06 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_SCREENCAST_H_
+#define MIR_TEST_DOUBLES_NULL_SCREENCAST_H_
+
+#include "mir/frontend/screencast.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class NullScreencast : public frontend::Screencast
+{
+public:
+    frontend::ScreencastSessionId create_session(
+        graphics::DisplayConfigurationOutputId)
+    {
+        return frontend::ScreencastSessionId{1};
+    }
+
+    void destroy_session(frontend::ScreencastSessionId) {}
+
+    std::shared_ptr<graphics::Buffer> capture(frontend::ScreencastSessionId)
+    {
+        return nullptr;
+    }
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_SCREENCAST_H_ */

=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2014-02-10 09:00:06 +0000
@@ -36,9 +36,9 @@
     {
         stub_compositor_buffer = std::make_shared<StubBuffer>();
     }
-    void swap_client_buffers(graphics::Buffer*& buffer) override
+    void swap_client_buffers(graphics::Buffer*, std::function<void(graphics::Buffer* new_buffer)> complete) override
     {
-        buffer = &stub_client_buffer;
+        complete(&stub_client_buffer);
     }
     std::shared_ptr<graphics::Buffer> lock_compositor_buffer(unsigned long) override
     {

=== modified file 'include/test/mir_test_doubles/stub_display_configuration.h'
--- include/test/mir_test_doubles/stub_display_configuration.h	2014-01-28 09:06:46 +0000
+++ include/test/mir_test_doubles/stub_display_configuration.h	2014-02-10 09:00:06 +0000
@@ -40,6 +40,13 @@
     {
     }
 
+    StubDisplayConfig(StubDisplayConfig const& other)
+        : graphics::DisplayConfiguration(),
+          cards(other.cards),
+          outputs(other.outputs)
+    {
+    }
+
     StubDisplayConfig(unsigned int num_displays)
         : StubDisplayConfig(num_displays,
                             {

=== modified file 'include/test/mir_test_doubles/stub_ipc_factory.h'
--- include/test/mir_test_doubles/stub_ipc_factory.h	2014-01-21 06:27:40 +0000
+++ include/test/mir_test_doubles/stub_ipc_factory.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -41,7 +41,7 @@
     }
 
     std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<frontend::EventSink> const&, bool) override
+        pid_t, std::shared_ptr<frontend::EventSink> const&, bool) override
     {
         return server;
     }

=== modified file 'include/test/mir_test_doubles/stub_shell.h'
--- include/test/mir_test_doubles/stub_shell.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_shell.h	2014-02-10 09:00:06 +0000
@@ -34,7 +34,7 @@
     StubShell() : stub_session(std::make_shared<StubSession>())
     {
     }
-    std::shared_ptr<frontend::Session> open_session(std::string const& /* name */, std::shared_ptr<frontend::EventSink> const& /* sink */) override
+    std::shared_ptr<frontend::Session> open_session(pid_t, std::string const& /* name */, std::shared_ptr<frontend::EventSink> const& /* sink */) override
     {
         return stub_session;
     }

=== modified file 'include/test/mir_test_doubles/stub_shell_session.h'
--- include/test/mir_test_doubles/stub_shell_session.h	2014-01-13 06:12:33 +0000
+++ include/test/mir_test_doubles/stub_shell_session.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -45,6 +45,11 @@
     {
         return std::string();
     }
+    pid_t process_id() const override
+    {
+        return -1;
+    }
+
     void force_requests_to_complete() override
     {
     }

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2014-01-28 09:06:46 +0000
+++ src/client/CMakeLists.txt	2014-02-10 09:00:06 +0000
@@ -72,7 +72,7 @@
   ${CLIENT_SOURCES}
 )
 
-set(MIRCLIENT_ABI 6)
+set(MIRCLIENT_ABI 7)
 
 set_target_properties(
   mirclient
@@ -117,7 +117,7 @@
   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
 install(
-  DIRECTORY ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit
+  DIRECTORY ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit ${CMAKE_SOURCE_DIR}/include/client/mir
   DESTINATION "include/mirclient"
 )
 

=== modified file 'src/client/mir_screencast.cpp'
--- src/client/mir_screencast.cpp	2014-01-24 18:11:19 +0000
+++ src/client/mir_screencast.cpp	2014-02-10 09:00:06 +0000
@@ -98,6 +98,8 @@
       egl_native_window_factory{egl_native_window_factory},
       buffer_depository{factory, mir::frontend::client_buffer_cache_size}
 {
+    protobuf_screencast.set_error("Not initialized");
+
     mir::protobuf::ScreencastParameters parameters;
     parameters.set_output_id(output_id);
     parameters.set_width(output_size.width.as_uint32_t());
@@ -117,6 +119,11 @@
     return &create_screencast_wait_handle;
 }
 
+bool MirScreencast::valid()
+{
+    return !protobuf_screencast.has_error();
+}
+
 MirSurfaceParameters MirScreencast::get_parameters() const
 {
     return MirSurfaceParameters{
@@ -188,7 +195,7 @@
     try
     {
         buffer_depository.deposit_package(buffer_package,
-                                          protobuf_buffer.buffer_id(),
+                                          buffer.buffer_id(),
                                           output_size, output_format);
     }
     catch (const std::runtime_error& err)
@@ -200,8 +207,11 @@
 void MirScreencast::screencast_created(
     mir_screencast_callback callback, void* context)
 {
-    egl_native_window_ = egl_native_window_factory->create_egl_native_window(this);
-    process_buffer(protobuf_screencast.buffer());
+    if (!protobuf_screencast.has_error())
+    {
+        egl_native_window_ = egl_native_window_factory->create_egl_native_window(this);
+        process_buffer(protobuf_screencast.buffer());
+    }
 
     callback(this, context);
     create_screencast_wait_handle.result_received();

=== modified file 'src/client/mir_screencast.h'
--- src/client/mir_screencast.h	2014-01-24 18:11:19 +0000
+++ src/client/mir_screencast.h	2014-02-10 09:00:06 +0000
@@ -49,6 +49,7 @@
         mir_screencast_callback callback, void* context);
 
     MirWaitHandle* creation_wait_handle();
+    bool valid();
 
     MirWaitHandle* release(
         mir_screencast_callback callback, void* context);

=== modified file 'src/client/mir_screencast_api.cpp'
--- src/client/mir_screencast_api.cpp	2014-01-29 09:16:50 +0000
+++ src/client/mir_screencast_api.cpp	2014-02-10 09:00:06 +0000
@@ -64,14 +64,21 @@
 
         auto const client_platform = connection->get_client_platform();
 
-        screencast = new MirScreencast{
-            find_display_output(*config, parameters->output_id),
-            connection->display_server(),
-            client_platform,
-            client_platform->create_buffer_factory(),
-            null_callback, nullptr};
-
-        screencast->creation_wait_handle()->wait_for_all();
+        std::unique_ptr<MirScreencast> screencast_uptr{
+            new MirScreencast{
+                find_display_output(*config, parameters->output_id),
+                connection->display_server(),
+                client_platform,
+                client_platform->create_buffer_factory(),
+                null_callback, nullptr}};
+
+        screencast_uptr->creation_wait_handle()->wait_for_all();
+
+        if (screencast_uptr->valid())
+        {
+            screencast = screencast_uptr.get();
+            screencast_uptr.release();
+        }
     }
     catch (std::exception const&)
     {

=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2014-01-13 06:12:33 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2014-02-10 09:00:06 +0000
@@ -143,6 +143,7 @@
     if (!disconnected.load())
     {
         auto surface = dynamic_cast<mir::protobuf::Surface*>(response);
+        mir::protobuf::Screencast* screencast{nullptr};
         if (surface)
         {
             surface->clear_fd();
@@ -157,12 +158,18 @@
                 rpc_report->file_descriptors_received(*response, fds);
             }
         }
+        else
+        {
+            screencast = dynamic_cast<mir::protobuf::Screencast*>(response);
+        }
 
         auto buffer = dynamic_cast<mir::protobuf::Buffer*>(response);
         if (!buffer)
         {
             if (surface && surface->has_buffer())
                 buffer = surface->mutable_buffer();
+            else if (screencast && screencast->has_buffer())
+                buffer = screencast->mutable_buffer();
         }
 
         if (buffer)

=== modified file 'src/platform/graphics/android/android_alloc_adaptor.cpp'
--- src/platform/graphics/android/android_alloc_adaptor.cpp	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/android_alloc_adaptor.cpp	2014-02-10 09:00:06 +0000
@@ -69,7 +69,7 @@
     }
 
     AndroidBufferHandleDeleter del1(alloc_dev);
-    std::shared_ptr<native_handle_t> handle(buf_handle, del1);
+    std::shared_ptr<native_handle_t const> handle(buf_handle, del1);
 
     auto ops = std::make_shared<mga::RealSyncFileOps>();
     auto fence = std::make_shared<mga::SyncFence>(ops, -1);

=== modified file 'src/platform/graphics/android/android_display.cpp'
--- src/platform/graphics/android/android_display.cpp	2014-01-21 06:27:40 +0000
+++ src/platform/graphics/android/android_display.cpp	2014-02-10 09:00:06 +0000
@@ -52,9 +52,11 @@
     f(*display_buffer);
 }
 
-std::shared_ptr<mg::DisplayConfiguration> mga::AndroidDisplay::configuration()
+std::unique_ptr<mg::DisplayConfiguration> mga::AndroidDisplay::configuration() const
 {
-    return std::make_shared<mga::AndroidDisplayConfiguration>(current_configuration);
+    return std::unique_ptr<mg::DisplayConfiguration>(
+        new mga::AndroidDisplayConfiguration(current_configuration)
+    );
 }
 
 void mga::AndroidDisplay::configure(mg::DisplayConfiguration const& configuration)

=== modified file 'src/platform/graphics/android/android_display.h'
--- src/platform/graphics/android/android_display.h	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/android_display.h	2014-02-10 09:00:06 +0000
@@ -48,8 +48,8 @@
 
     void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f);
 
-    std::shared_ptr<DisplayConfiguration> configuration();
-    void configure(DisplayConfiguration const&);
+    std::unique_ptr<DisplayConfiguration> configuration() const override;
+    void configure(DisplayConfiguration const&) override;
 
     void register_configuration_change_handler(
         EventHandlerRegister& handlers,

=== modified file 'src/platform/graphics/android/android_platform.cpp'
--- src/platform/graphics/android/android_platform.cpp	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/android_platform.cpp	2014-02-10 09:00:06 +0000
@@ -107,13 +107,11 @@
 
 extern "C" std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<mo::Option> const& /*options*/, std::shared_ptr<DisplayReport> const& display_report)
 {
-    //todo: could parse an option here
-    auto should_use_fb_fallback = false;
     auto buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
     auto display_resource_factory = std::make_shared<mga::ResourceFactory>();
     auto fb_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(buffer_initializer);
     auto display_builder = std::make_shared<mga::OutputBuilder>(
-        fb_allocator, display_resource_factory, display_report, should_use_fb_fallback);
+        fb_allocator, display_resource_factory, display_report);
     return std::make_shared<mga::AndroidPlatform>(display_builder, display_report);
 }
 

=== modified file 'src/platform/graphics/android/display_buffer.h'
--- src/platform/graphics/android/display_buffer.h	2014-01-23 17:26:51 +0000
+++ src/platform/graphics/android/display_buffer.h	2014-02-10 09:00:06 +0000
@@ -61,7 +61,6 @@
     std::shared_ptr<DisplayDevice> const display_device;
     std::shared_ptr<ANativeWindow> const native_window;
     GLContext gl_context;
-    bool prepared;
     MirOrientation rotation;
 };
 

=== modified file 'src/platform/graphics/android/hwc_device.cpp'
--- src/platform/graphics/android/hwc_device.cpp	2014-01-23 18:01:19 +0000
+++ src/platform/graphics/android/hwc_device.cpp	2014-02-10 09:00:06 +0000
@@ -35,10 +35,11 @@
 namespace geom = mir::geometry;
 
 mga::HwcDevice::HwcDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                              std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
+                          std::shared_ptr<HWCVsyncCoordinator> const& coordinator,
+                          std::shared_ptr<SyncFileOps> const& sync_ops)
     : HWCCommonDevice(hwc_device, coordinator),
       layer_list({mga::ForceGLLayer{}, mga::FramebufferLayer{}}),
-      sync_ops(std::make_shared<mga::RealSyncFileOps>())
+      sync_ops(sync_ops)
 {
 }
 
@@ -79,12 +80,8 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc set()"));
     }
 
-    if (last_display_fence)
-        last_display_fence->wait();
+    mga::SyncFence retire_fence(sync_ops, displays[HWC_DISPLAY_PRIMARY]->retireFenceFd);
 
     int framebuffer_fence = layer_list.framebuffer_fence();
     native_buffer->update_fence(framebuffer_fence);
-
-    last_display_fence = std::make_shared<mga::SyncFence>(
-        sync_ops, displays[HWC_DISPLAY_PRIMARY]->retireFenceFd);
 }

=== modified file 'src/platform/graphics/android/hwc_device.h'
--- src/platform/graphics/android/hwc_device.h	2014-01-23 18:01:19 +0000
+++ src/platform/graphics/android/hwc_device.h	2014-02-10 09:00:06 +0000
@@ -34,13 +34,13 @@
 {
 class HWCVsyncCoordinator;
 class SyncFileOps;
-class SyncFence;
 
 class HwcDevice : public HWCCommonDevice
 {
 public:
     HwcDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
+              std::shared_ptr<HWCVsyncCoordinator> const& coordinator,
+              std::shared_ptr<SyncFileOps> const& sync_ops);
 
     void prepare_gl();
     void prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const& list); 
@@ -50,10 +50,7 @@
 private:
     LayerList layer_list;
 
-    std::shared_ptr<SyncFence> last_display_fence;
     std::shared_ptr<SyncFileOps> const sync_ops;
-    unsigned int primary_display_config;
-    MirPixelFormat fb_format;
     static size_t const num_displays{3}; //primary, external, virtual
 };
 

=== modified file 'src/platform/graphics/android/hwc_layers.cpp'
--- src/platform/graphics/android/hwc_layers.cpp	2014-01-24 21:50:21 +0000
+++ src/platform/graphics/android/hwc_layers.cpp	2014-02-10 09:00:06 +0000
@@ -30,14 +30,18 @@
 
 mga::HWCLayer& mga::HWCLayer::operator=(HWCLayer const& layer)
 {
-    memcpy(this, &layer, sizeof(HWCLayer));
+    memcpy(static_cast<void*>(this),
+           static_cast<void const*>(&layer),
+           sizeof(HWCLayer));
     this->visibleRegionScreen = {1, &this->visible_rect};
     return *this;
 }
 
 mga::HWCLayer::HWCLayer(HWCLayer const& layer)
 {
-    memcpy(this, &layer, sizeof(HWCLayer));
+    memcpy(static_cast<void*>(this),
+           static_cast<void const*>(&layer),
+           sizeof(HWCLayer));
     this->visibleRegionScreen = {1, &this->visible_rect};
 }
 

=== modified file 'src/platform/graphics/android/internal_client_window.cpp'
--- src/platform/graphics/android/internal_client_window.cpp	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/internal_client_window.cpp	2014-02-10 09:00:06 +0000
@@ -25,6 +25,7 @@
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
+#include <sstream>
 
 namespace mg=mir::graphics;
 namespace mga=mg::android;
@@ -93,7 +94,11 @@
         case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
             return 1;
         default:
-            BOOST_THROW_EXCEPTION(std::runtime_error("driver requests info we dont provide. key: " + key));
+            {
+            std::stringstream sstream;
+            sstream << "driver requests info we dont provide. key: " << key;
+            BOOST_THROW_EXCEPTION(std::runtime_error(sstream.str()));
+            }
     }
 }
 

=== modified file 'src/platform/graphics/android/output_builder.cpp'
--- src/platform/graphics/android/output_builder.cpp	2014-01-21 18:09:35 +0000
+++ src/platform/graphics/android/output_builder.cpp	2014-02-10 09:00:06 +0000
@@ -33,22 +33,18 @@
 mga::OutputBuilder::OutputBuilder(
     std::shared_ptr<mga::GraphicBufferAllocator> const& buffer_allocator,
     std::shared_ptr<mga::DisplayResourceFactory> const& res_factory,
-    std::shared_ptr<mg::DisplayReport> const& display_report,
-    bool should_use_fb_fallback)
+    std::shared_ptr<mg::DisplayReport> const& display_report)
     : buffer_allocator(buffer_allocator),
       res_factory(res_factory),
       display_report(display_report),
-      force_backup_display(should_use_fb_fallback)
+      force_backup_display(false)
 {
-    if (!force_backup_display)
-    {
-        try
-        {
-            hwc_native = res_factory->create_hwc_native_device();
-        } catch (...)
-        {
-            force_backup_display = true;
-        }
+    try
+    {
+        hwc_native = res_factory->create_hwc_native_device();
+    } catch (...)
+    {
+        force_backup_display = true;
     }
 
     if (force_backup_display || hwc_native->common.version == HWC_DEVICE_API_VERSION_1_0)

=== modified file 'src/platform/graphics/android/output_builder.h'
--- src/platform/graphics/android/output_builder.h	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/output_builder.h	2014-02-10 09:00:06 +0000
@@ -40,8 +40,7 @@
     OutputBuilder(
         std::shared_ptr<GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<DisplayResourceFactory> const& res_factory,
-        std::shared_ptr<DisplayReport> const& display_report,
-        bool should_use_fb_fallback);
+        std::shared_ptr<DisplayReport> const& display_report);
 
     MirPixelFormat display_format();
     std::shared_ptr<DisplayDevice> create_display_device();

=== modified file 'src/platform/graphics/android/resource_factory.cpp'
--- src/platform/graphics/android/resource_factory.cpp	2014-01-21 18:09:35 +0000
+++ src/platform/graphics/android/resource_factory.cpp	2014-02-10 09:00:06 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "mir/graphics/android/mir_native_window.h"
+#include "mir/graphics/android/sync_fence.h"
 #include "buffer.h"
 #include "resource_factory.h"
 #include "fb_device.h"
@@ -91,7 +92,8 @@
     std::shared_ptr<hwc_composer_device_1> const& hwc_native_device) const
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
-    return std::make_shared<mga::HwcDevice>(hwc_native_device, syncer);
+    auto file_ops = std::make_shared<mga::RealSyncFileOps>();
+    return std::make_shared<mga::HwcDevice>(hwc_native_device, syncer, file_ops);
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc_fb_device(

=== modified file 'src/platform/graphics/android/server_render_window.cpp'
--- src/platform/graphics/android/server_render_window.cpp	2014-01-13 06:12:33 +0000
+++ src/platform/graphics/android/server_render_window.cpp	2014-02-10 09:00:06 +0000
@@ -28,6 +28,7 @@
 #include <system/window.h>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
+#include <sstream>
 
 namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
@@ -81,7 +82,11 @@
         case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
             return 1;
         default:
-            BOOST_THROW_EXCEPTION(std::runtime_error("driver requests info we dont provide. key: " + key));
+            {
+            std::stringstream sstream;
+            sstream << "driver requests info we dont provide. key: " << key;
+            BOOST_THROW_EXCEPTION(std::runtime_error(sstream.str()));
+            }
     }
 }
 

=== modified file 'src/platform/graphics/mesa/display.cpp'
--- src/platform/graphics/mesa/display.cpp	2014-01-22 08:32:55 +0000
+++ src/platform/graphics/mesa/display.cpp	2014-02-10 09:00:06 +0000
@@ -115,13 +115,15 @@
         f(*db_ptr);
 }
 
-std::shared_ptr<mg::DisplayConfiguration> mgm::Display::configuration()
+std::unique_ptr<mg::DisplayConfiguration> mgm::Display::configuration() const
 {
     std::lock_guard<std::mutex> lg{configuration_mutex};
 
     /* Give back a copy of the latest configuration information */
     current_display_configuration.update();
-    return std::make_shared<mgm::RealKMSDisplayConfiguration>(current_display_configuration);
+    return std::unique_ptr<mg::DisplayConfiguration>(
+        new mgm::RealKMSDisplayConfiguration(current_display_configuration)
+        );
 }
 
 void mgm::Display::configure(mg::DisplayConfiguration const& conf)

=== modified file 'src/platform/graphics/mesa/display.h'
--- src/platform/graphics/mesa/display.h	2014-01-22 08:32:55 +0000
+++ src/platform/graphics/mesa/display.h	2014-02-10 09:00:06 +0000
@@ -62,8 +62,8 @@
     void for_each_display_buffer(
         std::function<void(graphics::DisplayBuffer&)> const& f);
 
-    std::shared_ptr<DisplayConfiguration> configuration();
-    void configure(DisplayConfiguration const& conf);
+    std::unique_ptr<DisplayConfiguration> configuration() const override;
+    void configure(DisplayConfiguration const& conf) override;
 
     void register_configuration_change_handler(
         EventHandlerRegister& handlers,
@@ -83,14 +83,14 @@
 private:
     void clear_connected_unused_outputs();
 
-    std::mutex configuration_mutex;
+    mutable std::mutex configuration_mutex;
     std::shared_ptr<Platform> const platform;
     std::shared_ptr<DisplayReport> const listener;
     mir::udev::Monitor monitor;
     helpers::EGLHelper shared_egl;
     std::vector<std::unique_ptr<DisplayBuffer>> display_buffers;
     RealKMSOutputContainer output_container;
-    RealKMSDisplayConfiguration current_display_configuration;
+    mutable RealKMSDisplayConfiguration current_display_configuration;
     std::shared_ptr<Cursor> cursor;
 };
 

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2014-01-22 08:32:55 +0000
+++ src/server/CMakeLists.txt	2014-02-10 09:00:06 +0000
@@ -94,7 +94,7 @@
   )
 endif()
 
-set(MIRSERVER_ABI 14)
+set(MIRSERVER_ABI 15)
 
 set_target_properties(
   mirserver

=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2014-01-13 06:12:33 +0000
+++ src/server/compositor/buffer_bundle.h	2014-02-10 09:00:06 +0000
@@ -34,7 +34,7 @@
 {
 public:
     virtual ~BufferBundle() noexcept {}
-    virtual graphics::Buffer* client_acquire() = 0;
+    virtual void client_acquire(std::function<void(graphics::Buffer* buffer)> complete) = 0;
     virtual void client_release(graphics::Buffer*) = 0;
     virtual std::shared_ptr<graphics::Buffer>
         compositor_acquire(unsigned long frameno) = 0;

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2014-01-13 06:12:33 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2014-02-10 09:00:06 +0000
@@ -49,13 +49,14 @@
     return std::make_shared<mc::TemporarySnapshotBuffer>(buffer_bundle);
 }
 
-void mc::BufferStreamSurfaces::swap_client_buffers(mg::Buffer*& buffer)
+void mc::BufferStreamSurfaces::swap_client_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete)
 {
-    if (buffer)
+    if (old_buffer)
     {
-        buffer_bundle->client_release(buffer);
+        buffer_bundle->client_release(old_buffer);
     }
-    buffer = buffer_bundle->client_acquire();
+
+    buffer_bundle->client_acquire(complete);
 }
 
 MirPixelFormat mc::BufferStreamSurfaces::get_stream_pixel_format()

=== modified file 'src/server/compositor/buffer_stream_surfaces.h'
--- src/server/compositor/buffer_stream_surfaces.h	2014-01-13 06:12:33 +0000
+++ src/server/compositor/buffer_stream_surfaces.h	2014-02-10 09:00:06 +0000
@@ -39,7 +39,7 @@
     BufferStreamSurfaces(std::shared_ptr<BufferBundle> const& swapper);
     ~BufferStreamSurfaces();
 
-    void swap_client_buffers(graphics::Buffer*& buffer) override;
+    void swap_client_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) override;
 
     std::shared_ptr<graphics::Buffer>
         lock_compositor_buffer(unsigned long frameno) override;

=== modified file 'src/server/compositor/default_configuration.cpp'
--- src/server/compositor/default_configuration.cpp	2014-01-13 06:12:33 +0000
+++ src/server/compositor/default_configuration.cpp	2014-02-10 09:00:06 +0000
@@ -17,13 +17,17 @@
  */
 
 #include "mir/default_server_configuration.h"
+#include "mir/frontend/screencast.h"
 #include "buffer_stream_factory.h"
 #include "default_display_buffer_compositor_factory.h"
 #include "multi_threaded_compositor.h"
 #include "gl_renderer_factory.h"
 
+#include <boost/throw_exception.hpp>
+
 namespace mc = mir::compositor;
 namespace ms = mir::scene;
+namespace mf = mir::frontend;
 
 std::shared_ptr<ms::BufferStreamFactory>
 mir::DefaultServerConfiguration::the_buffer_stream_factory()
@@ -67,3 +71,31 @@
             return std::make_shared<mc::GLRendererFactory>();
         });
 }
+
+std::shared_ptr<mf::Screencast> mir::DefaultServerConfiguration::the_screencast()
+{
+    struct NotImplementedScreencast : mf::Screencast
+    {
+        mf::ScreencastSessionId create_session(
+            graphics::DisplayConfigurationOutputId)
+        {
+            BOOST_THROW_EXCEPTION(std::runtime_error("Screencast not implemented"));
+        }
+
+        void destroy_session(mf::ScreencastSessionId)
+        {
+            BOOST_THROW_EXCEPTION(std::runtime_error("Screencast not implemented"));
+        }
+
+        std::shared_ptr<graphics::Buffer> capture(mf::ScreencastSessionId)
+        {
+            BOOST_THROW_EXCEPTION(std::runtime_error("Screencast not implemented"));
+        }
+    };
+
+    return screencast(
+        [this]()
+        {
+            return std::make_shared<NotImplementedScreencast>();
+        });
+}

=== modified file 'src/server/compositor/switching_bundle.cpp'
--- src/server/compositor/switching_bundle.cpp	2014-01-23 18:42:20 +0000
+++ src/server/compositor/switching_bundle.cpp	2014-02-10 09:00:06 +0000
@@ -177,7 +177,7 @@
     return ring[slot].buf;
 }
 
-mg::Buffer* mc::SwitchingBundle::client_acquire()
+void mc::SwitchingBundle::client_acquire(std::function<void(graphics::Buffer* buffer)> complete)
 {
     std::unique_lock<std::mutex> lock(guard);
 
@@ -247,7 +247,7 @@
         ring[client].buf = ret;
     }
 
-    return ret.get();
+    complete(ret.get());
 }
 
 void mc::SwitchingBundle::client_release(graphics::Buffer* released_buffer)

=== modified file 'src/server/compositor/switching_bundle.h'
--- src/server/compositor/switching_bundle.h	2014-01-23 18:42:20 +0000
+++ src/server/compositor/switching_bundle.h	2014-02-10 09:00:06 +0000
@@ -49,7 +49,7 @@
 
     graphics::BufferProperties properties() const;
 
-    graphics::Buffer* client_acquire();
+    void client_acquire(std::function<void(graphics::Buffer* buffer)> complete) override;
     void client_release(graphics::Buffer* buffer);
     std::shared_ptr<graphics::Buffer>
         compositor_acquire(unsigned long frameno) override;

=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2013-10-16 07:34:22 +0000
+++ src/server/display_server.cpp	2014-02-10 09:00:06 +0000
@@ -27,6 +27,7 @@
 #include "mir/compositor/compositor.h"
 #include "mir/frontend/connector.h"
 #include "mir/graphics/display.h"
+#include "mir/graphics/display_configuration.h"
 #include "mir/input/input_manager.h"
 
 #include <stdexcept>
@@ -134,7 +135,8 @@
 
             if (configure_display_on_resume)
             {
-                auto conf = display->configuration();
+                std::shared_ptr<graphics::DisplayConfiguration> conf =
+                    display->configuration();
                 display_changer->configure_for_hardware_change(
                     conf, DisplayChanger::RetainSystemState);
                 configure_display_on_resume = false;
@@ -162,7 +164,8 @@
     {
         if (!paused)
         {
-            auto conf = display->configuration();
+            std::shared_ptr<graphics::DisplayConfiguration> conf =
+                display->configuration();
             display_changer->configure_for_hardware_change(
                 conf, DisplayChanger::PauseResumeSystem);
         }

=== modified file 'src/server/frontend/default_configuration.cpp'
--- src/server/frontend/default_configuration.cpp	2014-01-29 12:51:30 +0000
+++ src/server/frontend/default_configuration.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -42,13 +42,15 @@
         std::shared_ptr<mf::SessionMediatorReport> const& sm_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) :
+        std::shared_ptr<mg::GraphicBufferAllocator> const& buffer_allocator,
+        std::shared_ptr<mf::Screencast> const& screencast) :
         shell(shell),
         sm_report(sm_report),
         cache(std::make_shared<mf::ResourceCache>()),
         graphics_platform(graphics_platform),
         display_changer(display_changer),
-        buffer_allocator(buffer_allocator)
+        buffer_allocator(buffer_allocator),
+        screencast(screencast)
     {
     }
 
@@ -59,9 +61,12 @@
     std::shared_ptr<mg::Platform> const graphics_platform;
     std::shared_ptr<mf::DisplayChanger> const display_changer;
     std::shared_ptr<mg::GraphicBufferAllocator> const buffer_allocator;
+    std::shared_ptr<mf::Screencast> const screencast;
 
     virtual std::shared_ptr<mir::protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<mf::EventSink> const& sink, bool authorized_to_resize_display)
+        pid_t client_pid,
+        std::shared_ptr<mf::EventSink> const& sink,
+        bool authorized_to_resize_display) override
     {
         std::shared_ptr<mf::DisplayChanger> changer;
         if(authorized_to_resize_display)
@@ -74,13 +79,15 @@
         }
 
         return std::make_shared<mf::SessionMediator>(
+            client_pid,
             shell,
             graphics_platform,
             changer,
             buffer_allocator->supported_pixel_formats(),
             sm_report,
             sink,
-            resource_cache());
+            resource_cache(),
+            screencast);
     }
 
     virtual std::shared_ptr<mf::ResourceCache> resource_cache()
@@ -144,6 +151,8 @@
                 shell,
                 the_session_mediator_report(),
                 the_graphics_platform(),
-                the_frontend_display_changer(), allocator);
+                the_frontend_display_changer(),
+                allocator,
+                the_screencast());
         });
 }

=== modified file 'src/server/frontend/protobuf_ipc_factory.h'
--- src/server/frontend/protobuf_ipc_factory.h	2014-01-21 06:27:40 +0000
+++ src/server/frontend/protobuf_ipc_factory.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -19,6 +19,8 @@
 #ifndef MIR_FRONTEND_PROTOBUF_IPC_FACTORY_H_
 #define MIR_FRONTEND_PROTOBUF_IPC_FACTORY_H_
 
+#include <sys/types.h>
+
 #include <memory>
 
 namespace mir
@@ -37,7 +39,10 @@
 {
 public:
     virtual std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<EventSink> const& sink, bool authorized_to_resize_display) = 0;
+        pid_t client_pid,
+        std::shared_ptr<EventSink> const& sink,
+        bool authorized_to_resize_display) = 0;
+
     virtual std::shared_ptr<ResourceCache> resource_cache() = 0;
 
 protected:

=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
--- src/server/frontend/protobuf_message_processor.cpp	2014-01-28 09:06:46 +0000
+++ src/server/frontend/protobuf_message_processor.cpp	2014-02-10 09:00:06 +0000
@@ -21,6 +21,8 @@
 #include "mir/frontend/protobuf_message_sender.h"
 #include "mir/frontend/template_protobuf_message_processor.h"
 
+#include "mir_protobuf_wire.pb.h"
+
 namespace mfd = mir::frontend::detail;
 
 namespace
@@ -54,11 +56,70 @@
 template<> struct result_ptr_t<::mir::protobuf::Buffer>     { typedef ::mir::protobuf::Buffer* type; };
 template<> struct result_ptr_t<::mir::protobuf::Connection> { typedef ::mir::protobuf::Connection* type; };
 template<> struct result_ptr_t<::mir::protobuf::Surface>    { typedef ::mir::protobuf::Surface* type; };
-}
-}
-}
-
-bool mfd::ProtobufMessageProcessor::dispatch(mir::protobuf::wire::Invocation const& invocation)
+template<> struct result_ptr_t<::mir::protobuf::Screencast> { typedef ::mir::protobuf::Screencast* type; };
+
+template<>
+void invoke(
+    ProtobufMessageProcessor* self,
+    protobuf::DisplayServer* server,
+    void (protobuf::DisplayServer::*function)(
+        ::google::protobuf::RpcController* controller,
+        const protobuf::SurfaceId* request,
+        protobuf::Buffer* response,
+        ::google::protobuf::Closure* done),
+        Invocation const& invocation)
+{
+    protobuf::SurfaceId parameter_message;
+    parameter_message.ParseFromString(invocation.parameters());
+    auto const result_message = std::make_shared<protobuf::Buffer>();
+
+    auto const callback =
+        google::protobuf::NewCallback<
+            ProtobufMessageProcessor,
+            ::google::protobuf::uint32,
+             std::shared_ptr<protobuf::Buffer>>(
+                self,
+                &ProtobufMessageProcessor::send_response,
+                invocation.id(),
+                result_message);
+
+    try
+    {
+        (server->*function)(
+            0,
+            &parameter_message,
+            result_message.get(),
+            callback);
+    }
+    catch (std::exception const& x)
+    {
+        delete callback;
+        result_message->set_error(boost::diagnostic_information(x));
+        self->send_response(invocation.id(), result_message);
+    }
+}
+}
+}
+}
+
+
+const std::string& mfd::Invocation::method_name() const
+{
+    return invocation.method_name();
+}
+
+const std::string& mfd::Invocation::parameters() const
+{
+    return invocation.parameters();
+}
+
+google::protobuf::uint32 mfd::Invocation::id() const
+{
+    return invocation.id();
+}
+
+
+bool mfd::ProtobufMessageProcessor::dispatch(Invocation const& invocation)
 {
     report->received_invocation(display_server.get(), invocation.id(), invocation.method_name());
 
@@ -145,6 +206,11 @@
     sender->send_response(id, response, {fd});
 }
 
+void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, std::shared_ptr<protobuf::Buffer> response)
+{
+    send_response(id, response.get());
+}
+
 void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Connection* response)
 {
     const auto& fd = response->has_platform() ?
@@ -163,3 +229,13 @@
 
     sender->send_response(id, response, {surface_fd, buffer_fd});
 }
+
+void mfd::ProtobufMessageProcessor::send_response(
+    ::google::protobuf::uint32 id, mir::protobuf::Screencast* response)
+{
+    auto const& buffer_fd = response->has_buffer() ?
+        extract_fds_from(response->mutable_buffer()) :
+        std::vector<int32_t>();
+
+    sender->send_response(id, response, {buffer_fd});
+}

=== modified file 'src/server/frontend/protobuf_message_processor.h'
--- src/server/frontend/protobuf_message_processor.h	2014-01-22 15:54:11 +0000
+++ src/server/frontend/protobuf_message_processor.h	2014-02-10 09:00:06 +0000
@@ -52,9 +52,11 @@
     void send_response(::google::protobuf::uint32 id, protobuf::Buffer* response);
     void send_response(::google::protobuf::uint32 id, protobuf::Connection* response);
     void send_response(::google::protobuf::uint32 id, protobuf::Surface* response);
+    void send_response(::google::protobuf::uint32 id, std::shared_ptr<protobuf::Buffer> response);
+    void send_response(::google::protobuf::uint32 id, mir::protobuf::Screencast* response);
 
 private:
-    bool dispatch(mir::protobuf::wire::Invocation const& invocation);
+    bool dispatch(Invocation const& invocation);
 
     std::shared_ptr<ProtobufMessageSender> const sender;
     std::shared_ptr<protobuf::DisplayServer> const display_server;

=== modified file 'src/server/frontend/protobuf_session_creator.cpp'
--- src/server/frontend/protobuf_session_creator.cpp	2014-01-22 15:54:11 +0000
+++ src/server/frontend/protobuf_session_creator.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -69,7 +69,7 @@
         auto const event_sink = std::make_shared<detail::EventSender>(messenger);
         auto const msg_processor = create_processor(
             message_sender,
-            ipc_factory->make_ipc_server(event_sink, authorized_to_resize_display),
+            ipc_factory->make_ipc_server(client_pid, event_sink, authorized_to_resize_display),
             report);
 
         const auto& session = std::make_shared<mfd::SocketSession>(messenger, next_id(), connected_sessions, msg_processor);

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2014-01-13 06:12:33 +0000
+++ src/server/frontend/session_mediator.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -38,6 +38,7 @@
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/frontend/client_constants.h"
 #include "mir/frontend/event_sink.h"
+#include "mir/frontend/screencast.h"
 
 #include "mir/geometry/rectangles.h"
 #include "client_buffer_tracker.h"
@@ -55,20 +56,24 @@
 namespace geom = mir::geometry;
 
 mf::SessionMediator::SessionMediator(
+    pid_t client_pid,
     std::shared_ptr<frontend::Shell> const& shell,
     std::shared_ptr<graphics::Platform> const & graphics_platform,
     std::shared_ptr<mf::DisplayChanger> const& display_changer,
     std::vector<MirPixelFormat> const& surface_pixel_formats,
     std::shared_ptr<SessionMediatorReport> const& report,
     std::shared_ptr<EventSink> const& sender,
-    std::shared_ptr<ResourceCache> const& resource_cache) :
+    std::shared_ptr<ResourceCache> const& resource_cache,
+    std::shared_ptr<Screencast> const& screencast) :
+    client_pid(client_pid),
     shell(shell),
     graphics_platform(graphics_platform),
     surface_pixel_formats(surface_pixel_formats),
     display_changer(display_changer),
     report(report),
     event_sink(sender),
-    resource_cache(resource_cache)
+    resource_cache(resource_cache),
+    screencast(screencast)
 {
 }
 
@@ -92,7 +97,7 @@
 
     {
         std::unique_lock<std::mutex> lock(session_mutex);
-        weak_session = shell->open_session(request->application_name(), event_sink);
+        weak_session = shell->open_session(client_pid, request->application_name(), event_sink);
     }
 
     auto ipc_package = graphics_platform->get_ipc_package();
@@ -116,19 +121,25 @@
     done->Run();
 }
 
-std::tuple<mg::Buffer*, bool>
-mf::SessionMediator::advance_buffer(SurfaceId surf_id, Surface& surface)
+void mf::SessionMediator::advance_buffer(
+    SurfaceId surf_id,
+    Surface& surface,
+    std::function<void(graphics::Buffer*, bool)> complete)
 {
     auto& tracker = client_buffer_tracker[surf_id];
     if (!tracker) tracker = std::make_shared<ClientBufferTracker>(client_buffer_cache_size);
 
     auto& client_buffer = client_buffer_resource[surf_id];
-    surface.swap_buffers(client_buffer);
-    auto id = client_buffer->id();
-    auto need_full_ipc = !tracker->client_has(id);
-    tracker->add(id);
+    surface.swap_buffers(client_buffer,
+        [&tracker, &client_buffer, complete](mg::Buffer* new_buffer)
+        {
+            client_buffer = new_buffer;
+            auto id = client_buffer->id();
+            auto need_full_ipc = !tracker->client_has(id);
+            tracker->add(id);
 
-    return std::tie(client_buffer, need_full_ipc);
+            complete(client_buffer, need_full_ipc);
+        });
 }
 
 
@@ -138,49 +149,48 @@
     mir::protobuf::Surface* response,
     google::protobuf::Closure* done)
 {
-    bool need_full_ipc;
-    graphics::Buffer* client_buffer{nullptr};
-    std::shared_ptr<Session> session;
-
-    {
-        std::unique_lock<std::mutex> lock(session_mutex);
-
-        session = weak_session.lock();
-
-        if (session.get() == nullptr)
-            BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
-
-        report->session_create_surface_called(session->name());
-
-        auto const surf_id = session->create_surface(msh::SurfaceCreationParameters()
-            .of_name(request->surface_name())
-            .of_size(request->width(), request->height())
-            .of_buffer_usage(static_cast<graphics::BufferUsage>(request->buffer_usage()))
-            .of_pixel_format(static_cast<MirPixelFormat>(request->pixel_format()))
-            .with_output_id(graphics::DisplayConfigurationOutputId(request->output_id())));
-
-        auto surface = session->get_surface(surf_id);
-        response->mutable_id()->set_value(surf_id.as_value());
-        response->set_width(surface->size().width.as_uint32_t());
-        response->set_height(surface->size().height.as_uint32_t());
-        response->set_pixel_format((int)surface->pixel_format());
-        response->set_buffer_usage(request->buffer_usage());
-
-        if (surface->supports_input())
-            response->add_fd(surface->client_input_fd());
-
-        std::tie(client_buffer, need_full_ipc) = advance_buffer(surf_id, *surface);
-    }
-
-    auto buffer = response->mutable_buffer();
-    pack_protobuf_buffer(*buffer, client_buffer, need_full_ipc);
-
-    // TODO: NOTE: We use the ordering here to ensure the shell acts on the surface after the surface ID is sent over the wire.
-    // This guarantees that notifications such as, gained focus, etc, can be correctly interpreted by the client.
-    // To achieve this order we rely on done->Run() sending messages synchronously. As documented in mfd::SocketMessenger::send.
-    // this will require additional synchronization if mfd::SocketMessenger::send changes.
-    done->Run();
-    shell->handle_surface_created(session);
+
+    auto const lock = std::make_shared<std::unique_lock<std::mutex>>(session_mutex);
+
+    auto const session = weak_session.lock();
+
+    if (session.get() == nullptr)
+        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
+
+    report->session_create_surface_called(session->name());
+
+    auto const surf_id = session->create_surface(msh::SurfaceCreationParameters()
+        .of_name(request->surface_name())
+        .of_size(request->width(), request->height())
+        .of_buffer_usage(static_cast<graphics::BufferUsage>(request->buffer_usage()))
+        .of_pixel_format(static_cast<MirPixelFormat>(request->pixel_format()))
+        .with_output_id(graphics::DisplayConfigurationOutputId(request->output_id())));
+
+    auto surface = session->get_surface(surf_id);
+    response->mutable_id()->set_value(surf_id.as_value());
+    response->set_width(surface->size().width.as_uint32_t());
+    response->set_height(surface->size().height.as_uint32_t());
+    response->set_pixel_format((int)surface->pixel_format());
+    response->set_buffer_usage(request->buffer_usage());
+
+    if (surface->supports_input())
+        response->add_fd(surface->client_input_fd());
+
+    advance_buffer(surf_id, *surface,
+        [lock, this, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
+        {
+            lock->unlock();
+
+            auto buffer = response->mutable_buffer();
+            pack_protobuf_buffer(*buffer, client_buffer, need_full_ipc);
+
+            // TODO: NOTE: We use the ordering here to ensure the shell acts on the surface after the surface ID is sent over the wire.
+            // This guarantees that notifications such as, gained focus, etc, can be correctly interpreted by the client.
+            // To achieve this order we rely on done->Run() sending messages synchronously. As documented in mfd::SocketMessenger::send.
+            // this will require additional synchronization if mfd::SocketMessenger::send changes.
+            done->Run();
+            shell->handle_surface_created(session);
+        });
 }
 
 void mf::SessionMediator::next_buffer(
@@ -189,34 +199,34 @@
     ::mir::protobuf::Buffer* response,
     ::google::protobuf::Closure* done)
 {
-    bool need_full_ipc;
     SurfaceId const surf_id{request->value()};
-    graphics::Buffer* client_buffer{nullptr};
-
-    {
-        std::unique_lock<std::mutex> lock(session_mutex);
-
-        auto session = weak_session.lock();
-
-        if (session.get() == nullptr)
-            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(surf_id);
-
-        std::tie(client_buffer, need_full_ipc) = advance_buffer(surf_id, *surface);
-    }
-
-    pack_protobuf_buffer(*response, client_buffer, need_full_ipc);
-
-    done->Run();
+
+    auto const lock = std::make_shared<std::unique_lock<std::mutex>>(session_mutex);
+
+    auto const session = weak_session.lock();
+
+    if (session.get() == nullptr)
+        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(surf_id);
+
+    advance_buffer(surf_id, *surface,
+        [lock, this, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
+        {
+            lock->unlock();
+
+            pack_protobuf_buffer(*response, client_buffer, need_full_ipc);
+
+            done->Run();
+        });
 }
 
 void mf::SessionMediator::release_surface(
@@ -340,6 +350,59 @@
     done->Run();
 }
 
+void mf::SessionMediator::create_screencast(
+    google::protobuf::RpcController*,
+    const mir::protobuf::ScreencastParameters* parameters,
+    mir::protobuf::Screencast* protobuf_screencast,
+    google::protobuf::Closure* done)
+{
+    static bool const need_full_ipc{true};
+    mg::DisplayConfigurationOutputId const output_id{
+        static_cast<int>(parameters->output_id())};
+
+    auto screencast_session_id = screencast->create_session(output_id);
+    auto buffer = screencast->capture(screencast_session_id);
+
+    protobuf_screencast->mutable_screencast_id()->set_value(
+        screencast_session_id.as_value());
+    pack_protobuf_buffer(*protobuf_screencast->mutable_buffer(),
+                         buffer.get(),
+                         need_full_ipc);
+
+    done->Run();
+}
+
+void mf::SessionMediator::release_screencast(
+    google::protobuf::RpcController*,
+    const mir::protobuf::ScreencastId* protobuf_screencast_id,
+    mir::protobuf::Void*,
+    google::protobuf::Closure* done)
+{
+    ScreencastSessionId const screencast_session_id{
+        protobuf_screencast_id->value()};
+    screencast->destroy_session(screencast_session_id);
+    done->Run();
+}
+
+void mf::SessionMediator::screencast_buffer(
+    google::protobuf::RpcController*,
+    const mir::protobuf::ScreencastId* protobuf_screencast_id,
+    mir::protobuf::Buffer* protobuf_buffer,
+    google::protobuf::Closure* done)
+{
+    static bool const does_not_need_full_ipc{false};
+    ScreencastSessionId const screencast_session_id{
+        protobuf_screencast_id->value()};
+
+    auto buffer = screencast->capture(screencast_session_id);
+
+    pack_protobuf_buffer(*protobuf_buffer,
+                         buffer.get(),
+                         does_not_need_full_ipc);
+
+    done->Run();
+}
+
 void mf::SessionMediator::pack_protobuf_buffer(
     protobuf::Buffer& protobuf_buffer,
     graphics::Buffer* graphics_buffer,

=== modified file 'src/server/frontend/session_mediator.h'
--- src/server/frontend/session_mediator.h	2014-01-13 06:12:33 +0000
+++ src/server/frontend/session_mediator.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -24,6 +24,7 @@
 #include "mir/frontend/surface_id.h"
 #include "mir_toolkit/common.h"
 
+#include <functional>
 #include <unordered_map>
 #include <memory>
 #include <mutex>
@@ -52,19 +53,22 @@
 class SessionMediatorReport;
 class EventSink;
 class DisplayChanger;
+class Screencast;
 
 // SessionMediator relays requests from the client process into the server.
 class SessionMediator : public mir::protobuf::DisplayServer
 {
 public:
     SessionMediator(
+        pid_t client_pid,
         std::shared_ptr<Shell> const& shell,
         std::shared_ptr<graphics::Platform> const& graphics_platform,
         std::shared_ptr<frontend::DisplayChanger> const& display_changer,
         std::vector<MirPixelFormat> const& surface_pixel_formats,
         std::shared_ptr<SessionMediatorReport> const& report,
         std::shared_ptr<EventSink> const& event_sink,
-        std::shared_ptr<ResourceCache> const& resource_cache);
+        std::shared_ptr<ResourceCache> const& resource_cache,
+        std::shared_ptr<Screencast> const& screencast);
 
     ~SessionMediator() noexcept;
 
@@ -105,6 +109,21 @@
                        ::mir::protobuf::DisplayConfiguration* response,
                        ::google::protobuf::Closure* done) override;
 
+    void create_screencast(google::protobuf::RpcController*,
+                           const mir::protobuf::ScreencastParameters*,
+                           mir::protobuf::Screencast*,
+                           google::protobuf::Closure* done);
+
+    void release_screencast(google::protobuf::RpcController*,
+                            const mir::protobuf::ScreencastId*,
+                            mir::protobuf::Void*,
+                            google::protobuf::Closure* done);
+
+    void screencast_buffer(google::protobuf::RpcController*,
+                           const mir::protobuf::ScreencastId*,
+                           mir::protobuf::Buffer*,
+                           google::protobuf::Closure* done);
+
     /* Platform specific requests */
     void drm_auth_magic(google::protobuf::RpcController* controller,
                         const mir::protobuf::DRMMagic* request,
@@ -116,7 +135,8 @@
                               graphics::Buffer* graphics_buffer,
                               bool need_full_ipc);
 
-    std::tuple<graphics::Buffer*, bool> advance_buffer(SurfaceId surf_id, Surface& surface);
+    void advance_buffer(SurfaceId surf_id, Surface& surface, std::function<void(graphics::Buffer*, bool)> complete);
+    pid_t client_pid;
     std::shared_ptr<Shell> const shell;
     std::shared_ptr<graphics::Platform> const graphics_platform;
 
@@ -126,6 +146,7 @@
     std::shared_ptr<SessionMediatorReport> const report;
     std::shared_ptr<EventSink> const event_sink;
     std::shared_ptr<ResourceCache> const resource_cache;
+    std::shared_ptr<Screencast> const screencast;
 
     std::unordered_map<SurfaceId,graphics::Buffer*> client_buffer_resource;
     std::unordered_map<SurfaceId, std::shared_ptr<ClientBufferTracker>> client_buffer_tracker;

=== modified file 'src/server/frontend/surface.cpp'
--- src/server/frontend/surface.cpp	2014-01-13 06:12:33 +0000
+++ src/server/frontend/surface.cpp	2014-02-10 09:00:06 +0000
@@ -25,6 +25,10 @@
 
 #include "client_buffer_tracker.h"
 
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
 namespace mg = mir::graphics;
 namespace mf = mir::frontend;
 
@@ -39,7 +43,7 @@
     private:
         void swap_buffers(graphics::Buffer*& buffer)
         {
-            surface->swap_buffers(buffer);
+            surface->swap_buffers_blocking(buffer);
         }
         virtual mir::geometry::Size size() const { return surface->size(); }
         virtual MirPixelFormat pixel_format() const { return surface->pixel_format(); }
@@ -49,3 +53,23 @@
 
     return std::make_shared<ForwardingInternalSurface>(surface);
 }
+
+void mf::Surface::swap_buffers_blocking(graphics::Buffer*& buffer)
+{
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool done = false;
+
+    swap_buffers(buffer,
+        [&](mg::Buffer* new_buffer)
+        {
+            std::unique_lock<decltype(mutex)> lock(mutex);
+            buffer = new_buffer;
+            done = true;
+            cv.notify_one();
+        });
+
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    cv.wait(lock, [&]{ return done; });
+}

=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2014-01-13 06:12:33 +0000
+++ src/server/graphics/nested/nested_display.cpp	2014-02-10 09:00:06 +0000
@@ -152,9 +152,13 @@
         f(*i.second);
 }
 
-std::shared_ptr<mg::DisplayConfiguration> mgn::NestedDisplay::configuration()
+std::unique_ptr<mg::DisplayConfiguration> mgn::NestedDisplay::configuration() const
 {
-    return std::make_shared<NestedDisplayConfiguration>(mir_connection_create_display_config(*connection));
+    return std::unique_ptr<mg::DisplayConfiguration>(
+        new NestedDisplayConfiguration(
+            mir_connection_create_display_config(*connection)
+        )
+    );
 }
 
 void mgn::NestedDisplay::complete_display_initialization(MirPixelFormat format)

=== modified file 'src/server/graphics/nested/nested_display.h'
--- src/server/graphics/nested/nested_display.h	2014-01-13 06:12:33 +0000
+++ src/server/graphics/nested/nested_display.h	2014-02-10 09:00:06 +0000
@@ -102,7 +102,7 @@
 
     void for_each_display_buffer(std::function<void(DisplayBuffer&)>const& f) override;
 
-    std::shared_ptr<DisplayConfiguration> configuration() override;
+    std::unique_ptr<DisplayConfiguration> configuration() const override;
     void configure(DisplayConfiguration const&) override;
 
     void register_configuration_change_handler(

=== modified file 'src/server/graphics/offscreen/display.cpp'
--- src/server/graphics/offscreen/display.cpp	2014-01-10 08:51:30 +0000
+++ src/server/graphics/offscreen/display.cpp	2014-02-10 09:00:06 +0000
@@ -108,10 +108,12 @@
         f(*db_ptr);
 }
 
-std::shared_ptr<mg::DisplayConfiguration> mgo::Display::configuration()
+std::unique_ptr<mg::DisplayConfiguration> mgo::Display::configuration() const
 {
     std::lock_guard<std::mutex> lock{configuration_mutex};
-    return std::make_shared<mgo::DisplayConfiguration>(current_display_configuration);
+    return std::unique_ptr<mg::DisplayConfiguration>(
+        new mgo::DisplayConfiguration(current_display_configuration)
+    );
 }
 
 void mgo::Display::configure(mg::DisplayConfiguration const& conf)

=== modified file 'src/server/graphics/offscreen/display.h'
--- src/server/graphics/offscreen/display.h	2013-12-13 05:24:22 +0000
+++ src/server/graphics/offscreen/display.h	2014-02-10 09:00:06 +0000
@@ -71,8 +71,8 @@
 
     void for_each_display_buffer(std::function<void(DisplayBuffer&)> const& f);
 
-    std::shared_ptr<graphics::DisplayConfiguration> configuration();
-    void configure(graphics::DisplayConfiguration const& conf);
+    std::unique_ptr<graphics::DisplayConfiguration> configuration() const override;
+    void configure(graphics::DisplayConfiguration const& conf) override;
 
     void register_configuration_change_handler(
         EventHandlerRegister& handlers,
@@ -93,7 +93,7 @@
     std::shared_ptr<BasicPlatform> const basic_platform;
     detail::EGLDisplayHandle const egl_display;
     SurfacelessEGLContext const egl_context_shared;
-    std::mutex configuration_mutex;
+    mutable std::mutex configuration_mutex;
     DisplayConfiguration current_display_configuration;
     std::vector<std::unique_ptr<DisplayBuffer>> display_buffers;
 };

=== modified file 'src/server/scene/application_session.cpp'
--- src/server/scene/application_session.cpp	2014-01-13 06:12:33 +0000
+++ src/server/scene/application_session.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -37,11 +37,13 @@
 
 ms::ApplicationSession::ApplicationSession(
     std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
+    pid_t pid,
     std::string const& session_name,
     std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
     std::shared_ptr<msh::SessionListener> const& session_listener,
     std::shared_ptr<mf::EventSink> const& sink) :
     surface_factory(surface_factory),
+    pid(pid),
     session_name(session_name),
     snapshot_strategy(snapshot_strategy),
     session_listener(session_listener),
@@ -125,6 +127,11 @@
     return session_name;
 }
 
+pid_t ms::ApplicationSession::process_id() const
+{
+    return pid;
+}
+
 void ms::ApplicationSession::force_requests_to_complete()
 {
     std::unique_lock<std::mutex> lock(surfaces_mutex);

=== modified file 'src/server/scene/application_session.h'
--- src/server/scene/application_session.h	2014-01-13 06:12:33 +0000
+++ src/server/scene/application_session.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -45,6 +45,7 @@
 public:
     ApplicationSession(
         std::shared_ptr<shell::SurfaceFactory> const& surface_factory,
+        pid_t pid,
         std::string const& session_name,
         std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
         std::shared_ptr<shell::SessionListener> const& session_listener,
@@ -60,6 +61,7 @@
     std::shared_ptr<shell::Surface> default_surface() const;
 
     std::string name() const;
+    pid_t process_id() const override;
 
     void force_requests_to_complete();
 
@@ -77,6 +79,7 @@
 
 private:
     std::shared_ptr<shell::SurfaceFactory> const surface_factory;
+    pid_t const pid;
     std::string const session_name;
     std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
     std::shared_ptr<shell::SessionListener> const session_listener;

=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2014-01-24 08:29:36 +0000
+++ src/server/scene/basic_surface.cpp	2014-02-10 09:00:06 +0000
@@ -114,11 +114,11 @@
     return surface_buffer_stream->get_stream_pixel_format();
 }
 
-void ms::BasicSurface::swap_buffers(graphics::Buffer*& buffer)
+void ms::BasicSurface::swap_buffers(mg::Buffer* old_buffer, std::function<void(mg::Buffer* new_buffer)> complete)
 {
-    bool const posting{!!buffer};
+    bool const posting{!!old_buffer};
 
-    surface_buffer_stream->swap_client_buffers(buffer);
+    surface_buffer_stream->swap_client_buffers(old_buffer, complete);
 
     if (posting)
     {

=== modified file 'src/server/scene/basic_surface.h'
--- src/server/scene/basic_surface.h	2014-01-24 08:29:36 +0000
+++ src/server/scene/basic_surface.h	2014-02-10 09:00:06 +0000
@@ -73,7 +73,7 @@
     virtual MirPixelFormat pixel_format() const;
 
     virtual std::shared_ptr<graphics::Buffer> snapshot_buffer() const;
-    virtual void swap_buffers(graphics::Buffer*&);
+    virtual void swap_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete);
     virtual void force_requests_to_complete();
 
     virtual bool supports_input() const;

=== modified file 'src/server/scene/session_manager.cpp'
--- src/server/scene/session_manager.cpp	2014-01-13 06:12:33 +0000
+++ src/server/scene/session_manager.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -73,12 +73,14 @@
         close_session(session);
 }
 
-std::shared_ptr<mf::Session> ms::SessionManager::open_session(std::string const& name,
-                                                std::shared_ptr<mf::EventSink> const& sender)
+std::shared_ptr<mf::Session> ms::SessionManager::open_session(
+    pid_t client_pid,
+    std::string const& name,
+    std::shared_ptr<mf::EventSink> const& sender)
 {
     std::shared_ptr<msh::Session> new_session =
         std::make_shared<ApplicationSession>(
-            surface_factory, name, snapshot_strategy, session_listener, sender);
+            surface_factory, client_pid, name, snapshot_strategy, session_listener, sender);
 
     app_container->insert_session(new_session);
 

=== modified file 'src/server/scene/session_manager.h'
--- src/server/scene/session_manager.h	2014-01-13 06:12:33 +0000
+++ src/server/scene/session_manager.h	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -55,7 +55,10 @@
     virtual ~SessionManager();
 
     virtual std::shared_ptr<frontend::Session> open_session(
-        std::string const& name, std::shared_ptr<frontend::EventSink> const& sink);
+        pid_t client_pid,
+        std::string const& name,
+        std::shared_ptr<frontend::EventSink> const& sink);
+
     virtual void close_session(std::shared_ptr<frontend::Session> const& session);
 
     frontend::SurfaceId create_surface_for(std::shared_ptr<frontend::Session> const& session,

=== modified file 'src/server/scene/surface_impl.cpp'
--- src/server/scene/surface_impl.cpp	2014-01-24 08:29:36 +0000
+++ src/server/scene/surface_impl.cpp	2014-02-10 09:00:06 +0000
@@ -103,9 +103,9 @@
     return surface->pixel_format();
 }
 
-void ms::SurfaceImpl::swap_buffers(graphics::Buffer*& buffer)
+void ms::SurfaceImpl::swap_buffers(mg::Buffer* old_buffer, std::function<void(mg::Buffer* new_buffer)> complete)
 {
-    surface->swap_buffers(buffer);
+    surface->swap_buffers(old_buffer, complete);
 }
 
 void ms::SurfaceImpl::allow_framedropping(bool allow)

=== modified file 'src/server/scene/surface_impl.h'
--- src/server/scene/surface_impl.h	2014-01-13 06:12:33 +0000
+++ src/server/scene/surface_impl.h	2014-02-10 09:00:06 +0000
@@ -70,7 +70,7 @@
 
     virtual void with_most_recent_buffer_do(
         std::function<void(graphics::Buffer&)> const& exec);
-    virtual void swap_buffers(graphics::Buffer*& buffer);
+    virtual void swap_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) override;
 
     virtual bool supports_input() const;
     virtual int client_input_fd() const;

=== modified file 'src/utils/CMakeLists.txt'
--- src/utils/CMakeLists.txt	2014-01-10 05:48:41 +0000
+++ src/utils/CMakeLists.txt	2014-02-10 09:00:06 +0000
@@ -13,8 +13,17 @@
 add_executable(mirout out.c)
 target_link_libraries(mirout mirclient)
 
+add_executable(mirscreencast screencast.cpp)
+
+target_link_libraries(mirscreencast
+  mirclient
+  ${EGL_LIBRARIES}
+  ${GLESv2_LIBRARIES}
+)
+
 install(TARGETS
   mirping
   mirout
+  mirscreencast
   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 )

=== added file 'src/utils/screencast.cpp'
--- src/utils/screencast.cpp	1970-01-01 00:00:00 +0000
+++ src/utils/screencast.cpp	2014-02-10 09:00:06 +0000
@@ -0,0 +1,313 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir_toolkit/mir_client_library.h"
+#include "mir_toolkit/mir_screencast.h"
+#include "mir/geometry/size.h"
+
+#include "mir/raii.h"
+
+#include <getopt.h>
+#include <csignal>
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <fstream>
+#include <sstream>
+#include <thread>
+#include <iostream>
+#include <stdexcept>
+#include <future>
+#include <vector>
+
+namespace
+{
+
+volatile sig_atomic_t running = 1;
+
+void shutdown(int)
+{
+    running = 0;
+}
+
+std::future<void> write_frame_to_file(
+    std::vector<char> const& frame_data, int frame_number, GLenum format)
+{
+    return std::async(
+        std::launch::async,
+        [&frame_data, frame_number, format]
+        {
+            std::stringstream ss;
+            ss << "/tmp/mir_" ;
+            ss.width(5);
+            ss.fill('0');
+            ss << frame_number;
+            ss << (format == GL_BGRA_EXT ? ".bgra" : ".rgba");
+            std::ofstream f(ss.str());
+            f.write(frame_data.data(), frame_data.size());
+        });
+}
+
+GLenum read_pixels(mir::geometry::Size const& size, void* buffer)
+{
+    auto width = size.width.as_uint32_t();
+    auto height = size.height.as_uint32_t();
+
+    GLenum format = GL_BGRA_EXT;
+
+    glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, buffer);
+
+    if (glGetError() != GL_NO_ERROR)
+    {
+        format = GL_RGBA;
+        glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, buffer);
+    }
+
+    return format;
+}
+
+
+uint32_t get_first_valid_output_id(MirConnection* connection)
+{
+    auto const conf = mir::raii::deleter_for(
+        mir_connection_create_display_config(connection),
+        &mir_display_config_destroy);
+
+    if (conf == nullptr)
+        throw std::runtime_error("Failed to get display configuration\n");
+
+    for (unsigned i = 0; i < conf->num_outputs; ++i)
+    {
+        MirDisplayOutput const& output = conf->outputs[i];
+
+        if (output.connected && output.used &&
+            output.current_mode < output.num_modes)
+        {
+            return output.output_id;
+        }
+    }
+
+    throw std::runtime_error("Couldn't find a valid output to screencast");
+}
+
+mir::geometry::Size get_output_size(MirConnection* connection, uint32_t output_id)
+{
+    auto const conf = mir::raii::deleter_for(
+        mir_connection_create_display_config(connection),
+        &mir_display_config_destroy);
+
+    if (conf == nullptr)
+        throw std::runtime_error("Failed to get display configuration\n");
+
+    for (unsigned i = 0; i < conf->num_outputs; ++i)
+    {
+        MirDisplayOutput const& output = conf->outputs[i];
+
+        if (output.output_id == output_id &&
+            output.current_mode < output.num_modes)
+        {
+            MirDisplayMode const& mode = output.modes[output.current_mode];
+            return mir::geometry::Size{mode.horizontal_resolution, mode.vertical_resolution};
+        }
+    }
+
+    throw std::runtime_error("Couldn't get size of specified output");
+}
+
+void print_usage()
+{
+    std::cout << "Usage " << std::endl
+              << "    -m <Mir server socket>" << std::endl
+              << "    -o <Output id>" << std::endl
+              << "    -h: this help text" << std::endl;
+}
+
+struct EGLSetup
+{
+    EGLSetup(MirConnection* connection, MirScreencast* screencast)
+    {
+        static EGLint const attribs[] = {
+            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+            EGL_RED_SIZE, 8,
+            EGL_GREEN_SIZE, 8,
+            EGL_BLUE_SIZE, 8,
+            EGL_ALPHA_SIZE, 8,
+            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+            EGL_NONE};
+
+        static EGLint const context_attribs[] = {
+            EGL_CONTEXT_CLIENT_VERSION, 2,
+            EGL_NONE };
+
+        auto native_display =
+            reinterpret_cast<EGLNativeDisplayType>(
+                mir_connection_get_egl_native_display(connection));
+
+        auto native_window =
+            reinterpret_cast<EGLNativeWindowType>(
+                mir_screencast_egl_native_window(screencast));
+
+        egl_display = eglGetDisplay(native_display);
+
+        eglInitialize(egl_display, nullptr, nullptr);
+
+        int n;
+        eglChooseConfig(egl_display, attribs, &egl_config, 1, &n);
+
+        egl_surface = eglCreateWindowSurface(egl_display, egl_config, native_window, NULL);
+        if (egl_surface == EGL_NO_SURFACE)
+            throw std::runtime_error("Failed to create EGL screencast surface");
+
+        egl_context = eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, context_attribs);
+        if (egl_context == EGL_NO_CONTEXT)
+            throw std::runtime_error("Failed to create EGL context for screencast");
+
+        if (eglMakeCurrent(egl_display, egl_surface,
+                           egl_surface, egl_context) != EGL_TRUE)
+        {
+            throw std::runtime_error("Failed to make screencast surface current");
+        }
+    }
+
+    ~EGLSetup()
+    {
+        eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglDestroySurface(egl_display, egl_surface);
+        eglDestroyContext(egl_display, egl_context);
+        eglTerminate(egl_display);
+    }
+
+    void swap_buffers()
+    {
+        if (eglSwapBuffers(egl_display, egl_surface) != EGL_TRUE)
+            throw std::runtime_error("Failed to swap screencast surface buffers");
+    }
+
+    EGLDisplay egl_display;
+    EGLContext egl_context;
+    EGLSurface egl_surface;
+    EGLConfig egl_config;
+};
+
+void do_screencast(MirConnection* connection, MirScreencast* screencast,
+                   uint32_t output_id)
+{
+    static int const rgba_pixel_size{4};
+
+    auto const frame_size = get_output_size(connection, output_id);
+    auto const frame_size_bytes = rgba_pixel_size *
+                                  frame_size.width.as_uint32_t() *
+                                  frame_size.height.as_uint32_t();
+
+    int frame_number{0};
+    std::vector<char> frame_data(frame_size_bytes, 0);
+    std::future<void> frame_written_future =
+        std::async(std::launch::deferred, []{});
+
+    EGLSetup egl_setup{connection, screencast};
+
+    while (running)
+    {
+        frame_written_future.wait();
+
+        auto format = read_pixels(frame_size, frame_data.data());
+        frame_written_future = write_frame_to_file(frame_data, frame_number, format);
+
+        egl_setup.swap_buffers();
+        ++frame_number;
+    }
+}
+
+}
+
+int main(int argc, char* argv[])
+try
+{
+    int arg;
+    opterr = 0;
+    char const* socket_file = nullptr;
+    uint32_t output_id = mir_display_output_id_invalid;
+
+    while ((arg = getopt (argc, argv, "hm:o:")) != -1)
+    {
+        switch (arg)
+        {
+        case 'm':
+            socket_file = optarg;
+            break;
+
+        case 'o':
+            output_id = std::stoul(optarg);
+            break;
+
+        case '?':
+        case 'h':
+            print_usage();
+            return EXIT_SUCCESS;
+
+        default:
+            print_usage();
+            return EXIT_FAILURE;
+        }
+    }
+
+    signal(SIGINT, shutdown);
+    signal(SIGTERM, shutdown);
+
+    auto const connection = mir::raii::deleter_for(
+        mir_connect_sync(socket_file, "mirscreencast"),
+        [](MirConnection* c) { if (c) mir_connection_release(c); });
+
+    if (connection == nullptr || !mir_connection_is_valid(connection.get()))
+    {
+        std::string msg("Failed to connect to server.");
+        if (connection)
+        {
+            msg += " Error was :";
+            msg += mir_connection_get_error_message(connection.get());
+        }
+        throw std::runtime_error(std::string(msg));
+    }
+
+    if (output_id == mir_display_output_id_invalid)
+        output_id = get_first_valid_output_id(connection.get());
+
+    MirScreencastParameters params{
+        output_id, 0, 0, mir_pixel_format_invalid};
+
+    std::cout << "Starting screencast for output id " << params.output_id << std::endl;
+
+    auto const screencast = mir::raii::deleter_for(
+        mir_connection_create_screencast_sync(connection.get(), &params),
+        [](MirScreencast* s) { if (s) mir_screencast_release_sync(s); });
+
+    if (screencast == nullptr)
+        throw std::runtime_error("Failed to create screencast");
+
+    do_screencast(connection.get(), screencast.get(), output_id);
+
+    return EXIT_SUCCESS;
+}
+catch(std::exception const& e)
+{
+    std::cerr << e.what() << std::endl;
+
+    return EXIT_FAILURE;
+}

=== modified file 'tests/acceptance-tests/test_client_screencast.cpp'
--- tests/acceptance-tests/test_client_screencast.cpp	2014-01-29 17:20:51 +0000
+++ tests/acceptance-tests/test_client_screencast.cpp	2014-02-10 09:00:06 +0000
@@ -22,11 +22,11 @@
 #include "mir_test_framework/stubbed_server_configuration.h"
 #include "mir_test_framework/in_process_server.h"
 #include "mir_test_framework/using_stub_client_platform.h"
-#include "src/server/frontend/protobuf_ipc_factory.h"
-#include "mir_protobuf.pb.h"
 
 #include "mir_test_doubles/null_display_changer.h"
 #include "mir_test_doubles/stub_display_configuration.h"
+#include "mir_test_doubles/stub_buffer.h"
+#include "mir_test_doubles/mock_screencast.h"
 #include "mir_test/fake_shared.h"
 
 #include <gtest/gtest.h>
@@ -41,114 +41,6 @@
 namespace
 {
 
-ACTION(RunClosure)
-{
-    arg3->Run();
-}
-
-MATCHER_P(WithOutputId, value, "")
-{
-    return arg->output_id() == value;
-}
-
-MATCHER_P(WithScreencastId, value, "")
-{
-    return arg->value() == value;
-}
-
-ACTION_P(SetCreateScreencastId, screencast_id)
-{
-    arg2->mutable_screencast_id()->set_value(screencast_id);
-}
-
-ACTION(FillCreateScreencastBuffer)
-{
-    int fds[2]{-1,-1};
-    if (pipe(fds))
-        FAIL() << "Failed to create FillCreateScreencastBuffer fds";
-    close(fds[1]);
-    arg2->mutable_buffer()->add_fd(fds[0]);
-}
-
-/*
- * This setup is used temporarily to test MirScreencast, until
- * we have the server-side implementation of the feature in place.
- */
-struct MockScreencastServer : mir::protobuf::DisplayServer
-{
-    MockScreencastServer(
-        std::shared_ptr<mir::protobuf::DisplayServer> const& ds)
-        : wrapped_display_server{ds}
-    {
-        using namespace testing;
-        ON_CALL(*this, create_screencast(_,_,_,_))
-            .WillByDefault(DoAll(FillCreateScreencastBuffer(),RunClosure()));
-        ON_CALL(*this, release_screencast(_,_,_,_))
-            .WillByDefault(RunClosure());
-    }
-
-    void connect(
-        ::google::protobuf::RpcController* rpc,
-        const ::mir::protobuf::ConnectParameters* request,
-        ::mir::protobuf::Connection* response,
-        ::google::protobuf::Closure* done) override
-    {
-        wrapped_display_server->connect(rpc, request, response, done);
-    }
-
-    void disconnect(
-        google::protobuf::RpcController* rpc,
-        const mir::protobuf::Void* request,
-        mir::protobuf::Void* response,
-        google::protobuf::Closure* done) override
-    {
-        wrapped_display_server->disconnect(rpc, request, response, done);
-    }
-
-    MOCK_METHOD4(create_screencast,
-                 void(google::protobuf::RpcController*,
-                      const mir::protobuf::ScreencastParameters*,
-                      mir::protobuf::Screencast*,
-                      google::protobuf::Closure*));
-
-    MOCK_METHOD4(release_screencast,
-                 void(google::protobuf::RpcController*,
-                      const mir::protobuf::ScreencastId*,
-                      mir::protobuf::Void*,
-                      google::protobuf::Closure*));
-
-    std::shared_ptr<mir::protobuf::DisplayServer> const wrapped_display_server;
-};
-
-std::shared_ptr<MockScreencastServer> global_mock_screencast_server;
-
-class WrappingIpcFactory : public mf::ProtobufIpcFactory
-{
-public:
-    WrappingIpcFactory(
-        std::shared_ptr<mf::ProtobufIpcFactory> const& ipc_factory)
-        : wrapped_ipc_factory{ipc_factory}
-    {
-    }
-
-    std::shared_ptr<mir::protobuf::DisplayServer> make_ipc_server(
-        std::shared_ptr<mf::EventSink> const& sink, bool auth) override
-    {
-        auto ipc_server = wrapped_ipc_factory->make_ipc_server(sink, auth);
-        global_mock_screencast_server =
-            std::make_shared<testing::NiceMock<MockScreencastServer>>(ipc_server);
-        return global_mock_screencast_server;
-    }
-
-    std::shared_ptr<mf::ResourceCache> resource_cache() override
-    {
-        return wrapped_ipc_factory->resource_cache();
-    }
-
-private:
-    std::shared_ptr<mf::ProtobufIpcFactory> const wrapped_ipc_factory;
-};
-
 class StubChanger : public mtd::NullDisplayChanger
 {
 public:
@@ -179,27 +71,22 @@
         return mt::fake_shared(stub_changer);
     }
 
-    std::shared_ptr<mf::ProtobufIpcFactory> the_ipc_factory(
-        std::shared_ptr<mf::Shell> const& shell,
-        std::shared_ptr<mg::GraphicBufferAllocator> const& alloc) override
+    std::shared_ptr<mf::Screencast> the_screencast() override
     {
-        auto factory = mtf::StubbedServerConfiguration::the_ipc_factory(shell, alloc);
-        return std::make_shared<WrappingIpcFactory>(factory);
+        return mt::fake_shared(mock_screencast);
     }
 
     StubChanger stub_changer;
+    mtd::MockScreencast mock_screencast;
 };
 
 class MirScreencastTest : public mir_test_framework::InProcessServer
 {
 public:
-    ~MirScreencastTest()
-    {
-        global_mock_screencast_server.reset();
-    }
-
     mir::DefaultServerConfiguration& server_config() override { return server_config_; }
 
+    mtd::MockScreencast& mock_screencast() { return server_config_.mock_screencast; }
+
     StubServerConfig server_config_;
     mtf::UsingStubClientPlatform using_stub_client_platform;
 };
@@ -227,8 +114,7 @@
     uint32_t const invalid_output_id{33};
     MirScreencastParameters params{invalid_output_id, 0, 0, mir_pixel_format_invalid};
 
-    EXPECT_CALL(*global_mock_screencast_server,
-                create_screencast(_,_,_,_))
+    EXPECT_CALL(mock_screencast(), create_session(_))
         .Times(0);
 
     auto screencast =
@@ -238,28 +124,27 @@
     mir_connection_release(connection);
 }
 
-TEST_F(MirScreencastTest, create_and_release_contact_server)
+TEST_F(MirScreencastTest, contacts_server_screencast_for_create_and_release)
 {
     using namespace testing;
 
     auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
     ASSERT_TRUE(mir_connection_is_valid(connection));
 
-    uint32_t const screencast_id{99};
+    mf::ScreencastSessionId const screencast_session_id{99};
     uint32_t const output_id{2};
     MirScreencastParameters params{output_id, 0, 0, mir_pixel_format_invalid};
 
     InSequence seq;
 
-    EXPECT_CALL(*global_mock_screencast_server,
-                create_screencast(_,WithOutputId(output_id),_,_))
-        .WillOnce(DoAll(SetCreateScreencastId(screencast_id),
-                        FillCreateScreencastBuffer(),
-                        RunClosure()));
-
-    EXPECT_CALL(*global_mock_screencast_server,
-                release_screencast(_,WithScreencastId(screencast_id),_,_))
-        .WillOnce(RunClosure());
+    EXPECT_CALL(mock_screencast(),
+                create_session(mg::DisplayConfigurationOutputId{output_id}))
+        .WillOnce(Return(screencast_session_id));
+
+    EXPECT_CALL(mock_screencast(), capture(screencast_session_id))
+        .WillOnce(Return(std::make_shared<mtd::StubBuffer>()));
+
+    EXPECT_CALL(mock_screencast(), destroy_session(screencast_session_id));
 
     auto screencast = mir_connection_create_screencast_sync(connection, &params);
     ASSERT_NE(nullptr, screencast);
@@ -275,9 +160,17 @@
     auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
     ASSERT_TRUE(mir_connection_is_valid(connection));
 
+    mf::ScreencastSessionId const screencast_session_id{99};
     uint32_t const output_id{2};
     MirScreencastParameters params{output_id, 0, 0, mir_pixel_format_invalid};
 
+    InSequence seq;
+    EXPECT_CALL(mock_screencast(), create_session(_))
+        .WillOnce(Return(screencast_session_id));
+    EXPECT_CALL(mock_screencast(), capture(_))
+        .WillOnce(Return(std::make_shared<mtd::StubBuffer>()));
+    EXPECT_CALL(mock_screencast(), destroy_session(_));
+
     auto screencast = mir_connection_create_screencast_sync(connection, &params);
     ASSERT_NE(nullptr, screencast);
 
@@ -288,3 +181,22 @@
 
     mir_connection_release(connection);
 }
+
+TEST_F(MirScreencastTest, fails_on_client_when_server_request_fails)
+{
+    using namespace testing;
+
+    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+    ASSERT_TRUE(mir_connection_is_valid(connection));
+
+    uint32_t const output_id{2};
+    MirScreencastParameters params{output_id, 0, 0, mir_pixel_format_invalid};
+
+    EXPECT_CALL(mock_screencast(), create_session(_))
+        .WillOnce(Throw(std::runtime_error("")));
+
+    auto screencast = mir_connection_create_screencast_sync(connection, &params);
+    ASSERT_EQ(nullptr, screencast);
+
+    mir_connection_release(connection);
+}

=== modified file 'tests/acceptance-tests/test_display_configuration.cpp'
--- tests/acceptance-tests/test_display_configuration.cpp	2014-01-13 06:12:33 +0000
+++ tests/acceptance-tests/test_display_configuration.cpp	2014-02-10 09:00:06 +0000
@@ -87,9 +87,11 @@
         f(display_buffer);
     }
 
-    std::shared_ptr<mg::DisplayConfiguration> configuration()
+    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
     {
-        return config;
+        return std::unique_ptr<mg::DisplayConfiguration>(
+            new mtd::StubDisplayConfig(*config)
+        );
     }
 
     void register_configuration_change_handler(
@@ -112,7 +114,7 @@
     MOCK_METHOD1(configure, void(mg::DisplayConfiguration const&));
 
     void emit_configuration_change_event(
-        std::shared_ptr<mg::DisplayConfiguration> const& new_config)
+        std::shared_ptr<mtd::StubDisplayConfig> const& new_config)
     {
         config = new_config;
         if (write(p.write_fd(), "a", 1)) {}
@@ -125,7 +127,7 @@
     }
 
 private:
-    std::shared_ptr<mg::DisplayConfiguration> config;
+    std::shared_ptr<mtd::StubDisplayConfig> config;
     mtd::NullDisplayBuffer display_buffer;
     mt::Pipe p;
     std::atomic<bool> handler_called;

=== modified file 'tests/acceptance-tests/test_protobuf.cpp'
--- tests/acceptance-tests/test_protobuf.cpp	2014-01-21 12:49:00 +0000
+++ tests/acceptance-tests/test_protobuf.cpp	2014-02-10 09:00:06 +0000
@@ -75,7 +75,7 @@
         sender(sender),
         wrapped(wrapped) {}
 
-    bool dispatch(mir::protobuf::wire::Invocation const& invocation)
+    bool dispatch(mfd::Invocation const& invocation)
     {
         if ("function" == invocation.method_name())
         {

=== modified file 'tests/acceptance-tests/test_surfaces_with_output_id.cpp'
--- tests/acceptance-tests/test_surfaces_with_output_id.cpp	2014-01-13 06:12:33 +0000
+++ tests/acceptance-tests/test_surfaces_with_output_id.cpp	2014-02-10 09:00:06 +0000
@@ -66,9 +66,11 @@
             f(*db);
     }
 
-    std::shared_ptr<mg::DisplayConfiguration> configuration() override
+    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
     {
-        return std::make_shared<mtd::StubDisplayConfig>(rects);
+        return std::unique_ptr<mg::DisplayConfiguration>(
+            new mtd::StubDisplayConfig(rects)
+        );
     }
 
 private:

=== modified file 'tests/draw/android_graphics.cpp'
--- tests/draw/android_graphics.cpp	2014-01-13 06:12:33 +0000
+++ tests/draw/android_graphics.cpp	2014-02-10 09:00:06 +0000
@@ -48,28 +48,6 @@
     gralloc_module_t *grmod;
     native_handle_t const* handle;
 };
-
-static const char* proc_dir = "/proc";
-static const char* surface_flinger_executable_name = "surfaceflinger";
-int surface_flinger_filter(const struct dirent* d)
-{
-    if (fnmatch("[1-9]*", d->d_name, 0))
-        return 0;
-
-    char path[256];
-    snprintf(path, sizeof(path), "%s/%s/cmdline", proc_dir, d->d_name);
-
-    std::ifstream in(path);
-    std::string line;
-
-    while(std::getline(in, line))
-    {
-        if (line.find(surface_flinger_executable_name) != std::string::npos)
-            return 1;
-    }
-
-    return 0;
-}
 }
 
 mtd::TestGrallocMapper::TestGrallocMapper()

=== modified file 'tests/integration-tests/client/CMakeLists.txt'
--- tests/integration-tests/client/CMakeLists.txt	2013-10-15 08:53:10 +0000
+++ tests/integration-tests/client/CMakeLists.txt	2014-02-10 09:00:06 +0000
@@ -4,9 +4,14 @@
   APPEND INTEGRATION_TESTS_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/test_client_render.cpp
 )
+endif()
+
+list(
+  APPEND INTEGRATION_TESTS_SRCS
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_screencast.cpp
+)
 
 set(
   INTEGRATION_TESTS_SRCS
   ${INTEGRATION_TESTS_SRCS}
   PARENT_SCOPE)
-endif()

=== added file 'tests/integration-tests/client/test_screencast.cpp'
--- tests/integration-tests/client/test_screencast.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/client/test_screencast.cpp	2014-02-10 09:00:06 +0000
@@ -0,0 +1,191 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir_protobuf.pb.h"
+#include "src/client/default_connection_configuration.h"
+
+#include "mir/frontend/connector.h"
+#include "mir_test/test_protobuf_server.h"
+#include "mir_test/stub_server_tool.h"
+#include "mir_test/pipe.h"
+
+#include <gtest/gtest.h>
+
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <boost/throw_exception.hpp>
+
+namespace mcl = mir::client;
+namespace mt = mir::test;
+
+namespace
+{
+
+class WaitObject
+{
+public:
+    void notify_ready()
+    {
+        std::unique_lock<std::mutex> lock{mutex};
+        ready = true;
+        cv.notify_all();
+    }
+
+    void wait_until_ready()
+    {
+        std::unique_lock<std::mutex> lock{mutex};
+        if (!cv.wait_for(lock, std::chrono::seconds{10}, [this] { return ready; }))
+        {
+            BOOST_THROW_EXCEPTION(std::runtime_error("WaitObject timed out"));
+        }
+    }
+
+private:
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool ready = false;
+};
+
+struct StubScreencastServerTool : mt::StubServerTool
+{
+    void create_screencast(
+        google::protobuf::RpcController*,
+        const mir::protobuf::ScreencastParameters*,
+        mir::protobuf::Screencast* response,
+        google::protobuf::Closure* done) override
+    {
+        response->mutable_buffer()->add_fd(pipe.read_fd());
+        done->Run();
+    }
+
+    void screencast_buffer(
+        ::google::protobuf::RpcController*,
+        ::mir::protobuf::ScreencastId const*,
+        ::mir::protobuf::Buffer* response,
+        ::google::protobuf::Closure* done) override
+    {
+        response->add_fd(pipe.read_fd());
+        done->Run();
+    }
+
+    mt::Pipe pipe;
+};
+
+struct MirScreencastTest : public testing::Test
+{
+    MirScreencastTest()
+        : server_tool{std::make_shared<StubScreencastServerTool>()}
+    {
+        std::remove(test_socket);
+        test_server =
+            std::make_shared<mt::TestProtobufServer>(test_socket, server_tool);
+        test_server->comm->start();
+
+        rpc_channel =
+            mcl::DefaultConnectionConfiguration{test_socket}.the_rpc_channel();
+        protobuf_server =
+            std::make_shared<mir::protobuf::DisplayServer::Stub>(rpc_channel.get());
+    }
+
+    char const* const test_socket = "./test_socket_screencast";
+    std::shared_ptr<StubScreencastServerTool> const server_tool;
+    std::shared_ptr<mt::TestProtobufServer> test_server;
+    std::shared_ptr<google::protobuf::RpcChannel> rpc_channel;
+    std::shared_ptr<mir::protobuf::DisplayServer> protobuf_server;
+};
+
+}
+
+TEST_F(MirScreencastTest, gets_buffer_fd_when_creating_screencast)
+{
+    std::vector<char> const cookie{'2','3','l','$'};
+
+    ASSERT_EQ(static_cast<ssize_t>(cookie.size()),
+              write(server_tool->pipe.write_fd(), cookie.data(), cookie.size()));
+
+    mir::protobuf::ScreencastParameters protobuf_parameters;
+    protobuf_parameters.set_output_id(0);
+    protobuf_parameters.set_width(0);
+    protobuf_parameters.set_height(0);
+    mir::protobuf::Screencast protobuf_screencast;
+
+    WaitObject wait_rpc;
+
+    protobuf_server->create_screencast(
+        nullptr,
+        &protobuf_parameters,
+        &protobuf_screencast,
+        google::protobuf::NewCallback(&wait_rpc, &WaitObject::notify_ready));
+
+    wait_rpc.wait_until_ready();
+
+    ASSERT_EQ(1, protobuf_screencast.buffer().fd_size());
+    auto const read_fd = protobuf_screencast.buffer().fd(0);
+
+    // The received FD should be different from the original pipe fd,
+    // since we are sending it over our IPC mechanism, which for
+    // the purposes of this test, lives in the same process.
+    // TODO: Don't depend on IPC implementation details
+    EXPECT_NE(read_fd, server_tool->pipe.read_fd());
+
+    std::vector<char> received(cookie.size(), '\0');
+    EXPECT_EQ(static_cast<ssize_t>(cookie.size()),
+              read(read_fd, received.data(), received.size()));
+    EXPECT_EQ(cookie, received);
+
+    close(read_fd);
+}
+
+TEST_F(MirScreencastTest, gets_buffer_fd_when_getting_screencast_buffer)
+{
+    std::vector<char> const cookie{'X','%','q','S'};
+
+    ASSERT_EQ(static_cast<ssize_t>(cookie.size()),
+              write(server_tool->pipe.write_fd(), cookie.data(), cookie.size()));
+
+    mir::protobuf::ScreencastId protobuf_screencast_id;
+    protobuf_screencast_id.set_value(0);
+    mir::protobuf::Buffer protobuf_buffer;
+
+    WaitObject wait_rpc;
+
+    protobuf_server->screencast_buffer(
+        nullptr,
+        &protobuf_screencast_id,
+        &protobuf_buffer,
+        google::protobuf::NewCallback(&wait_rpc, &WaitObject::notify_ready));
+
+    wait_rpc.wait_until_ready();
+
+    ASSERT_EQ(1, protobuf_buffer.fd_size());
+    auto const read_fd = protobuf_buffer.fd(0);
+
+    // The received FD should be different from the original pipe fd,
+    // since we are sending it over our IPC mechanism, which, for
+    // the purposes of this test, lives in the same process.
+    // TODO: Don't depend on IPC implementation details
+    EXPECT_NE(read_fd, server_tool->pipe.read_fd());
+
+    std::vector<char> received(cookie.size(), '\0');
+    EXPECT_EQ(static_cast<ssize_t>(cookie.size()),
+              read(read_fd, received.data(), received.size()));
+    EXPECT_EQ(cookie, received);
+
+    close(read_fd);
+}

=== modified file 'tests/integration-tests/compositor/test_buffer_stream.cpp'
--- tests/integration-tests/compositor/test_buffer_stream.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/compositor/test_buffer_stream.cpp	2014-02-10 09:00:06 +0000
@@ -26,6 +26,7 @@
 
 #include <gmock/gmock.h>
 
+#include <condition_variable>
 #include <thread>
 #include <chrono>
 #include <atomic>
@@ -38,6 +39,31 @@
 
 namespace
 {
+struct BufferStreamSurfaces : mc::BufferStreamSurfaces
+{
+    using mc::BufferStreamSurfaces::BufferStreamSurfaces;
+
+    // Convenient function to allow tests to be written in linear style
+    void swap_client_buffers_blocking(mg::Buffer*& buffer)
+    {
+        std::mutex mutex;
+        std::condition_variable cv;
+        bool done = false;
+
+        swap_client_buffers(buffer,
+            [&](mg::Buffer* new_buffer)
+             {
+                std::unique_lock<decltype(mutex)> lock(mutex);
+                buffer = new_buffer;
+                done = true;
+                cv.notify_one();
+             });
+
+        std::unique_lock<decltype(mutex)> lock(mutex);
+
+        cv.wait(lock, [&]{ return done; });
+    }
+};
 
 struct BufferStreamTest : public ::testing::Test
 {
@@ -60,7 +86,7 @@
     }
 
     const int nbuffers;
-    mc::BufferStreamSurfaces buffer_stream;
+    BufferStreamSurfaces buffer_stream;
 };
 
 }
@@ -68,9 +94,9 @@
 TEST_F(BufferStreamTest, gives_same_back_buffer_until_more_available)
 {
     mg::Buffer* client1{nullptr};
-    buffer_stream.swap_client_buffers(client1);
+    buffer_stream.swap_client_buffers_blocking(client1);
     auto client1_id = client1->id();
-    buffer_stream.swap_client_buffers(client1);
+    buffer_stream.swap_client_buffers_blocking(client1);
 
     auto comp1 = buffer_stream.lock_compositor_buffer(1);
     auto comp2 = buffer_stream.lock_compositor_buffer(1);
@@ -80,7 +106,7 @@
 
     comp1.reset();
 
-    buffer_stream.swap_client_buffers(client1);
+    buffer_stream.swap_client_buffers_blocking(client1);
     auto comp3 = buffer_stream.lock_compositor_buffer(2);
 
     EXPECT_NE(client1_id, comp3->id());
@@ -97,7 +123,7 @@
 {
     mg::Buffer* client_buffer{nullptr};
     for (int i = 0; i !=  nbuffers; i++)
-        buffer_stream.swap_client_buffers(client_buffer);
+        buffer_stream.swap_client_buffers_blocking(client_buffer);
 
     auto first_monitor = buffer_stream.lock_compositor_buffer(1);
     auto first_compositor_id = first_monitor->id();
@@ -113,14 +139,14 @@
 TEST_F(BufferStreamTest, gives_different_back_buffer_asap)
 {
     mg::Buffer* client_buffer{nullptr};
-    buffer_stream.swap_client_buffers(client_buffer);
+    buffer_stream.swap_client_buffers_blocking(client_buffer);
 
     if (nbuffers > 1)
     {
-        buffer_stream.swap_client_buffers(client_buffer);
+        buffer_stream.swap_client_buffers_blocking(client_buffer);
         auto comp1 = buffer_stream.lock_compositor_buffer(1);
 
-        buffer_stream.swap_client_buffers(client_buffer);
+        buffer_stream.swap_client_buffers_blocking(client_buffer);
         auto comp2 = buffer_stream.lock_compositor_buffer(2);
 
         EXPECT_NE(comp1->id(), comp2->id());
@@ -135,7 +161,7 @@
     auto old_size = buffer_stream.stream_size();
 
     mg::Buffer* client{nullptr};
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
     EXPECT_EQ(old_size, client->size());
 
     geom::Size const new_size
@@ -146,13 +172,13 @@
     buffer_stream.resize(new_size);
     EXPECT_EQ(new_size, buffer_stream.stream_size());
 
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
     EXPECT_EQ(new_size, client->size());
 
     buffer_stream.resize(old_size);
     EXPECT_EQ(old_size, buffer_stream.stream_size());
 
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
     EXPECT_EQ(old_size, client->size());
 }
 
@@ -161,7 +187,7 @@
     auto old_size = buffer_stream.stream_size();
 
     mg::Buffer* client{nullptr};
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
 
     geom::Size const new_size
     {
@@ -171,8 +197,8 @@
     buffer_stream.resize(new_size);
     EXPECT_EQ(new_size, buffer_stream.stream_size());
 
-    buffer_stream.swap_client_buffers(client);
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
+    buffer_stream.swap_client_buffers_blocking(client);
 
     auto comp1 = buffer_stream.lock_compositor_buffer(1);
     EXPECT_EQ(old_size, comp1->size());
@@ -182,7 +208,7 @@
     EXPECT_EQ(new_size, comp2->size());
     comp2.reset();
 
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
 
     auto comp3 = buffer_stream.lock_compositor_buffer(3);
     EXPECT_EQ(new_size, comp3->size());
@@ -192,13 +218,13 @@
     EXPECT_EQ(old_size, buffer_stream.stream_size());
 
     // No client frames "drawn" since resize(old_size), so compositor gets new_size
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
     auto comp4 = buffer_stream.lock_compositor_buffer(4);
     EXPECT_EQ(new_size, comp4->size());
     comp4.reset();
 
     // Generate a new frame, which should be back to old_size now
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
     auto comp5 = buffer_stream.lock_compositor_buffer(5);
     EXPECT_EQ(old_size, comp5->size());
     comp5.reset();
@@ -207,8 +233,8 @@
 TEST_F(BufferStreamTest, can_get_partly_released_back_buffer)
 {
     mg::Buffer* client{nullptr};
-    buffer_stream.swap_client_buffers(client);
-    buffer_stream.swap_client_buffers(client);
+    buffer_stream.swap_client_buffers_blocking(client);
+    buffer_stream.swap_client_buffers_blocking(client);
 
     auto comp1 = buffer_stream.lock_compositor_buffer(123);
     auto comp2 = buffer_stream.lock_compositor_buffer(123);
@@ -225,12 +251,12 @@
 namespace
 {
 
-void client_loop(int nframes, mc::BufferStream& stream)
+void client_loop(int nframes, BufferStreamSurfaces& stream)
 {
     mg::Buffer* out_buffer{nullptr};
     for (int f = 0; f < nframes; f++)
     {
-        stream.swap_client_buffers(out_buffer);
+        stream.swap_client_buffers_blocking(out_buffer);
         ASSERT_NE(nullptr, out_buffer);
         std::this_thread::yield();
     }

=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2014-02-10 09:00:06 +0000
@@ -51,6 +51,31 @@
     std::shared_ptr<mc::SwitchingBundle> switching_bundle;
     std::atomic<bool> client_thread_done;
 };
+
+auto client_acquire_blocking(std::shared_ptr<mc::SwitchingBundle> const& switching_bundle)
+-> mg::Buffer*
+{
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool done = false;
+
+    mg::Buffer* result;
+    switching_bundle->client_acquire(
+        [&](mg::Buffer* new_buffer)
+         {
+            std::unique_lock<decltype(mutex)> lock(mutex);
+
+            result = new_buffer;
+            done = true;
+            cv.notify_one();
+         });
+
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    cv.wait(lock, [&]{ return done; });
+
+    return result;
+}
 }
 
 TEST_F(SwapperSwappingStress, swapper)
@@ -62,7 +87,7 @@
                 {
                     for(auto i=0u; i < 400; i++)
                     {
-                        auto b = switching_bundle->client_acquire();
+                        auto b = client_acquire_blocking(switching_bundle);
                         std::this_thread::yield();
                         switching_bundle->client_release(b);
                     }
@@ -107,7 +132,7 @@
                 {
                     for(auto i=0u; i < 400; i++)
                     {
-                        auto b = switching_bundle->client_acquire();
+                        auto b = client_acquire_blocking(switching_bundle);
                         std::this_thread::yield();
                         switching_bundle->client_release(b);
                     }

=== modified file 'tests/integration-tests/graphics/android/test_buffer_integration.cpp'
--- tests/integration-tests/graphics/android/test_buffer_integration.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/graphics/android/test_buffer_integration.cpp	2014-02-10 09:00:06 +0000
@@ -55,6 +55,30 @@
     mtd::TestGrallocMapper sw_renderer;
 };
 
+auto client_acquire_blocking(mc::SwitchingBundle& switching_bundle)
+-> mg::Buffer*
+{
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool done = false;
+
+    mg::Buffer* result;
+    switching_bundle.client_acquire(
+        [&](mg::Buffer* new_buffer)
+         {
+            std::unique_lock<decltype(mutex)> lock(mutex);
+
+            result = new_buffer;
+            done = true;
+            cv.notify_one();
+         });
+
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    cv.wait(lock, [&]{ return done; });
+
+    return result;
+}
 }
 
 TEST_F(AndroidBufferIntegration, allocator_can_create_sw_buffer)
@@ -92,7 +116,7 @@
 
     mc::SwitchingBundle swapper(2, allocator, buffer_properties);
 
-    auto returned_buffer = swapper.client_acquire();
+    auto returned_buffer = client_acquire_blocking(swapper);
 
     EXPECT_NE(nullptr, returned_buffer);
 }

=== modified file 'tests/integration-tests/graphics/android/test_display_integration.cpp'
--- tests/integration-tests/graphics/android/test_display_integration.cpp	2014-01-21 06:27:40 +0000
+++ tests/integration-tests/graphics/android/test_display_integration.cpp	2014-02-10 09:00:06 +0000
@@ -38,7 +38,7 @@
 
 namespace
 {
-class AndroidGPUDisplay : public ::testing::Test
+class AndroidDisplay : public ::testing::Test
 {
 protected:
     static void SetUpTestCase()
@@ -65,42 +65,17 @@
     static void (*original_sigterm_handler)(int);
 };
 
-void (*AndroidGPUDisplay::original_sigterm_handler)(int);
-std::shared_ptr<mga::ResourceFactory> AndroidGPUDisplay::display_resource_factory;
-}
-
-// disabled to unblock CI - see lp:1239955
-TEST_F(AndroidGPUDisplay, DISABLED_gpu_display_ok_with_gles)
-{
-    auto should_use_fb_fallback = true;
-    auto buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
-    auto fb_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(buffer_initializer);
-    auto mock_display_report = std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>();
-    auto display_buffer_factory = std::make_shared<mga::OutputBuilder>(
-        fb_allocator, display_resource_factory, mock_display_report, should_use_fb_fallback);
-
-    mga::AndroidDisplay display(display_buffer_factory, mock_display_report);
-    display.for_each_display_buffer([this](mg::DisplayBuffer& buffer)
-    {
-        buffer.make_current();
-        gl_animation.init_gl();
-
-        gl_animation.render_gl();
-        buffer.post_update();
-
-        gl_animation.render_gl();
-        buffer.post_update();
-    });
-}
-
-TEST_F(AndroidGPUDisplay, hwc_display_ok_with_gles)
-{
-    auto should_use_fb_fallback = false;
-    auto mock_display_report = std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>();
-    auto buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
-    auto fb_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(buffer_initializer);
-    auto display_buffer_factory = std::make_shared<mga::OutputBuilder>(
-        fb_allocator, display_resource_factory, mock_display_report, should_use_fb_fallback);
+void (*AndroidDisplay::original_sigterm_handler)(int);
+std::shared_ptr<mga::ResourceFactory> AndroidDisplay::display_resource_factory;
+}
+
+TEST_F(AndroidDisplay, display_can_post)
+{
+    auto mock_display_report = std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>();
+    auto buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
+    auto fb_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(buffer_initializer);
+    auto display_buffer_factory = std::make_shared<mga::OutputBuilder>(
+        fb_allocator, display_resource_factory, mock_display_report);
 
     mga::AndroidDisplay display(display_buffer_factory, mock_display_report);
     display.for_each_display_buffer([this](mg::DisplayBuffer& buffer)

=== modified file 'tests/integration-tests/graphics/android/test_internal_client.cpp'
--- tests/integration-tests/graphics/android/test_internal_client.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/graphics/android/test_internal_client.cpp	2014-02-10 09:00:06 +0000
@@ -98,8 +98,9 @@
     auto ss = std::make_shared<ms::SurfaceStack>(surface_allocator, stub_input_registrar, scene_report);
     auto surface_controller = std::make_shared<ms::SurfaceController>(ss);
     auto surface_source = std::make_shared<ms::SurfaceSource>(surface_controller, std::make_shared<mtd::NullSurfaceConfigurator>());
-    auto mir_surface = as_internal_surface(
-        surface_source->create_surface(nullptr, params, id, std::shared_ptr<mf::EventSink>()));
+    auto surface = surface_source->create_surface(nullptr, params, id, std::shared_ptr<mf::EventSink>());
+    surface->allow_framedropping(true);
+    auto mir_surface = as_internal_surface(surface);
 
     auto options = std::shared_ptr<mo::ProgramOption>();
     auto report = std::shared_ptr<mg::NullDisplayReport>();

=== modified file 'tests/integration-tests/test_display_server_main_loop_events.cpp'
--- tests/integration-tests/test_display_server_main_loop_events.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/test_display_server_main_loop_events.cpp	2014-02-10 09:00:06 +0000
@@ -94,9 +94,11 @@
         display->for_each_display_buffer(f);
     }
 
-    std::shared_ptr<mg::DisplayConfiguration> configuration() override
+    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
     {
-        return display->configuration();
+        return std::unique_ptr<mg::DisplayConfiguration>(
+            new mtd::NullDisplayConfiguration
+        );
     }
 
     MOCK_METHOD1(configure, void(mg::DisplayConfiguration const&));

=== modified file 'tests/integration-tests/test_session.cpp'
--- tests/integration-tests/test_session.cpp	2014-01-14 07:02:27 +0000
+++ tests/integration-tests/test_session.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -170,6 +170,7 @@
 
     ms::ApplicationSession session{
         conf.the_shell_surface_factory(),
+        __LINE__,
         "stress",
         conf.the_snapshot_strategy(),
         std::make_shared<msh::NullSessionListener>(),
@@ -189,7 +190,7 @@
             for (int i = 0; i < 500; ++i)
             {
                 auto surface = session.default_surface();
-                surface->swap_buffers(buffer);
+                surface->swap_buffers_blocking(buffer);
                 std::this_thread::sleep_for(std::chrono::microseconds{50});
             }
         }};

=== modified file 'tests/integration-tests/test_session_manager.cpp'
--- tests/integration-tests/test_session_manager.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/test_session_manager.cpp	2014-02-10 09:00:06 +0000
@@ -76,9 +76,9 @@
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
-    auto session1 = session_manager.open_session("Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
-    auto session2 = session_manager.open_session("Microsoft Access", std::make_shared<mtd::NullEventSink>());
-    auto session3 = session_manager.open_session("WordPerfect", std::make_shared<mtd::NullEventSink>());
+    auto session1 = session_manager.open_session(__LINE__, "Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
+    auto session2 = session_manager.open_session(__LINE__, "Microsoft Access", std::make_shared<mtd::NullEventSink>());
+    auto session3 = session_manager.open_session(__LINE__, "WordPerfect", std::make_shared<mtd::NullEventSink>());
 
     Mock::VerifyAndClearExpectations(&focus_setter);
 
@@ -105,9 +105,9 @@
 
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
-    auto session1 = session_manager.open_session("Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
-    auto session2 = session_manager.open_session("Microsoft Access", std::make_shared<mtd::NullEventSink>());
-    auto session3 = session_manager.open_session("WordPerfect", std::make_shared<mtd::NullEventSink>());
+    auto session1 = session_manager.open_session(__LINE__, "Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
+    auto session2 = session_manager.open_session(__LINE__, "Microsoft Access", std::make_shared<mtd::NullEventSink>());
+    auto session3 = session_manager.open_session(__LINE__, "WordPerfect", std::make_shared<mtd::NullEventSink>());
 
     Mock::VerifyAndClearExpectations(&focus_setter);
 

=== modified file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2014-02-10 09:00:06 +0000
@@ -56,14 +56,22 @@
     {
     }
 
-    void swap_client_buffers(mg::Buffer*& buffer) { buffer = &stub_buffer; }
-    std::shared_ptr<mg::Buffer> lock_compositor_buffer(unsigned long) { return std::make_shared<mtd::StubBuffer>(); }
-    std::shared_ptr<mg::Buffer> lock_snapshot_buffer() { return std::make_shared<mtd::StubBuffer>(); }
-    MirPixelFormat get_stream_pixel_format() { return mir_pixel_format_abgr_8888; }
-    geom::Size stream_size() { return geom::Size{}; }
+    void swap_client_buffers(mg::Buffer*, std::function<void(mg::Buffer* new_buffer)> complete) override
+        { complete(&stub_buffer); }
+
+    std::shared_ptr<mg::Buffer> lock_compositor_buffer(unsigned long) override
+        { return std::make_shared<mtd::StubBuffer>(); }
+
+    std::shared_ptr<mg::Buffer> lock_snapshot_buffer() override
+        { return std::make_shared<mtd::StubBuffer>(); }
+
+    MirPixelFormat get_stream_pixel_format() override
+        { return mir_pixel_format_abgr_8888; }
+
+    geom::Size stream_size() override { return geom::Size{}; }
     void resize(geom::Size const&) override {}
-    void force_requests_to_complete() {}
-    void allow_framedropping(bool)
+    void force_requests_to_complete() override {}
+    void allow_framedropping(bool) override
     {
         while (write(render_operations_fd, "a", 1) != 1) continue;
     }

=== modified file 'tests/mir_test_framework/stubbed_server_configuration.cpp'
--- tests/mir_test_framework/stubbed_server_configuration.cpp	2014-01-29 12:51:30 +0000
+++ tests/mir_test_framework/stubbed_server_configuration.cpp	2014-02-10 09:00:06 +0000
@@ -120,7 +120,7 @@
 class StubDisplayConfiguration : public mtd::NullDisplayConfiguration
 {
 public:
-    StubDisplayConfiguration(geom::Rectangle& rect)
+    StubDisplayConfiguration(geom::Rectangle const& rect)
          : modes{mg::DisplayConfigurationMode{rect.size, 1.0f}}
     {
     }
@@ -156,9 +156,11 @@
         f(display_buffer);
     }
 
-    std::shared_ptr<mg::DisplayConfiguration> configuration() override
+    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
     {
-        return std::make_shared<StubDisplayConfiguration>(rect);
+        return std::unique_ptr<mg::DisplayConfiguration>(
+            new StubDisplayConfiguration(rect)
+        );
     }
 
 private:

=== modified file 'tests/unit-tests/client/test_mir_screencast.cpp'
--- tests/unit-tests/client/test_mir_screencast.cpp	2014-01-24 18:11:19 +0000
+++ tests/unit-tests/client/test_mir_screencast.cpp	2014-02-10 09:00:06 +0000
@@ -67,12 +67,17 @@
     void create_screencast(
         google::protobuf::RpcController* /*controller*/,
         mp::ScreencastParameters const* /*request*/,
-        mp::Screencast* /*response*/,
+        mp::Screencast* response,
         google::protobuf::Closure* done) override
     {
         if (server_thread.joinable())
             server_thread.join();
-        server_thread = std::thread{[done, this] { done->Run(); }};
+        server_thread = std::thread{
+            [response, done, this]
+            {
+                response->clear_error();
+                done->Run();
+            }};
     }
 
     void release_screencast(
@@ -151,6 +156,7 @@
 
 ACTION_P(SetCreateScreencastId, screencast_id)
 {
+    arg2->clear_error();
     arg2->mutable_screencast_id()->set_value(screencast_id);
 }
 
@@ -166,6 +172,7 @@
 
 ACTION_P(SetCreateBufferFromPackage, package)
 {
+    arg2->clear_error();
     auto buffer = arg2->mutable_buffer();
     for (int i = 0; i != package.data_items; ++i)
     {
@@ -180,6 +187,11 @@
     buffer->set_stride(package.stride);
 }
 
+ACTION(SetCreateError)
+{
+    arg2->set_error("Test error");
+}
+
 ACTION(RunClosure)
 {
     arg3->Run();
@@ -521,3 +533,41 @@
 
     EXPECT_EQ(StubEGLNativeWindowFactory::egl_native_window, egl_native_window);
 }
+
+TEST_F(MirScreencastTest, is_invalid_if_server_create_screencast_fails)
+{
+    using namespace testing;
+
+    EXPECT_CALL(mock_server, create_screencast(_,_,_,_))
+        .WillOnce(DoAll(SetCreateError(), RunClosure()));
+
+    MirScreencast screencast{
+        default_mir_output, mock_server,
+        stub_egl_native_window_factory,
+        stub_client_buffer_factory,
+        null_callback_func, nullptr};
+
+    screencast.creation_wait_handle()->wait_for_all();
+
+    EXPECT_FALSE(screencast.valid());
+}
+
+TEST_F(MirScreencastTest, calls_callback_on_creation_failure)
+{
+    using namespace testing;
+
+    MockCallback mock_cb;
+    EXPECT_CALL(mock_server, create_screencast(_,_,_,_))
+        .WillOnce(DoAll(SetCreateError(), RunClosure()));
+    EXPECT_CALL(mock_cb, call(_,&mock_cb));
+
+    MirScreencast screencast{
+        default_mir_output, mock_server,
+        stub_egl_native_window_factory,
+        stub_client_buffer_factory,
+        mock_callback_func, &mock_cb};
+
+    screencast.creation_wait_handle()->wait_for_all();
+
+    EXPECT_FALSE(screencast.valid());
+}

=== modified file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	2014-02-10 09:00:06 +0000
@@ -25,6 +25,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <condition_variable>
+
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
@@ -122,22 +124,50 @@
 
 TEST_F(BufferStreamTest, get_buffer_for_client_releases_resources)
 {
-    using namespace testing;
-    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
+    std::mutex mutex;
+    std::condition_variable cv;
     mg::Buffer* buffer{nullptr};
+    bool done = false;
+
+    auto const callback =
+        [&](mg::Buffer* new_buffer)
+        {
+           std::unique_lock<decltype(mutex)> lock(mutex);
+           buffer = new_buffer;
+           done = true;
+           cv.notify_one();
+        };
+
+    using namespace testing;
+    mc::BufferStreamSurfaces buffer_stream(mock_bundle);
 
     InSequence seq;
-    EXPECT_CALL(*mock_bundle, client_acquire())
+    EXPECT_CALL(*mock_bundle, client_acquire(_))
         .Times(1)
-        .WillOnce(Return(mock_buffer.get()));
+        .WillOnce(InvokeArgument<0>(mock_buffer.get()));
     EXPECT_CALL(*mock_bundle, client_release(_))
         .Times(1);
-    EXPECT_CALL(*mock_bundle, client_acquire())
+    EXPECT_CALL(*mock_bundle, client_acquire(_))
         .Times(1)
-        .WillOnce(Return(mock_buffer.get()));
-
-    buffer_stream.swap_client_buffers(buffer);
-    buffer_stream.swap_client_buffers(buffer);
+        .WillOnce(InvokeArgument<0>(mock_buffer.get()));
+
+    buffer_stream.swap_client_buffers(buffer, callback);
+
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+
+        cv.wait(lock, [&]{ return done; });
+    }
+
+    done = false;
+
+    buffer_stream.swap_client_buffers(buffer, callback);
+
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+
+        cv.wait(lock, [&]{ return done; });
+    }
 }
 
 TEST_F(BufferStreamTest, allow_framedropping_device)

=== modified file 'tests/unit-tests/compositor/test_switching_bundle.cpp'
--- tests/unit-tests/compositor/test_switching_bundle.cpp	2014-01-22 14:15:29 +0000
+++ tests/unit-tests/compositor/test_switching_bundle.cpp	2014-02-10 09:00:06 +0000
@@ -34,6 +34,8 @@
 
 using namespace testing;
 
+namespace
+{
 struct SwitchingBundleTest : public ::testing::Test
 {
     void SetUp()
@@ -52,6 +54,32 @@
     mg::BufferProperties basic_properties;
 };
 
+auto client_acquire_blocking(mc::SwitchingBundle& switching_bundle)
+-> mg::Buffer*
+{
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool done = false;
+
+    mg::Buffer* result;
+    switching_bundle.client_acquire(
+        [&](mg::Buffer* new_buffer)
+         {
+            std::unique_lock<decltype(mutex)> lock(mutex);
+
+            result = new_buffer;
+            done = true;
+            cv.notify_one();
+         });
+
+    std::unique_lock<decltype(mutex)> lock(mutex);
+
+    cv.wait(lock, [&]{ return done; });
+
+    return result;
+}
+}
+
 TEST_F(SwitchingBundleTest, sync_swapper_by_default)
 {
     mg::BufferProperties properties{geom::Size{7, 8},
@@ -100,7 +128,7 @@
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
 
-        auto buffer = bundle.client_acquire();
+        auto buffer = client_acquire_blocking(bundle);
         bundle.client_release(buffer);
     }
 }
@@ -132,7 +160,7 @@
 
         for (int i = 0; i < 20; i++)
         {
-            auto client1 = bundle.client_acquire();
+            auto client1 = client_acquire_blocking(bundle);
             mg::BufferID expect_id = client1->id(), composited_id;
             bundle.client_release(client1);
 
@@ -173,7 +201,7 @@
         {
             for (int j = 0; j < 100; j++)
             {
-                auto client = bundle.client_acquire();
+                auto client = client_acquire_blocking(bundle);
                 last_client_id = client->id();
                 bundle.client_release(client);
             }
@@ -197,11 +225,11 @@
 {  // Regression test for LP: #1210042
     mc::SwitchingBundle bundle(3, allocator, basic_properties);
 
-    auto client1 = bundle.client_acquire();
+    auto client1 = client_acquire_blocking(bundle);
     auto client1_id = client1->id();
     bundle.client_release(client1);
 
-    auto client2 = bundle.client_acquire();
+    auto client2 = client_acquire_blocking(bundle);
     bundle.client_release(client2);
 
     auto compositor = bundle.compositor_acquire(1);
@@ -217,8 +245,8 @@
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
 
-        auto client1 = bundle.client_acquire();
-        auto client2 = bundle.client_acquire();
+        auto client1 = client_acquire_blocking(bundle);
+        auto client2 = client_acquire_blocking(bundle);
         EXPECT_THROW(
             bundle.client_release(client2),
             std::logic_error
@@ -241,7 +269,7 @@
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
         unsigned long frameno = 0;
 
-        auto client = bundle.client_acquire();
+        auto client = client_acquire_blocking(bundle);
         auto client_id = client->id();
         bundle.client_release(client);
 
@@ -291,7 +319,7 @@
         {
             if (i % 10 == 0)
             {
-                auto client = bundle.client_acquire();
+                auto client = client_acquire_blocking(bundle);
                 client_id = client->id();
                 bundle.client_release(client);
             }
@@ -317,7 +345,7 @@
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
         unsigned long frameno = 0;
 
-        auto client = bundle.client_acquire();
+        auto client = client_acquire_blocking(bundle);
         bundle.client_release(client);
 
         auto compositor1 = bundle.compositor_acquire(++frameno);
@@ -342,11 +370,11 @@
     mg::Buffer* client_buffer = nullptr;
     std::shared_ptr<mg::Buffer> compositor_buffer = nullptr;
 
-    client_buffer = bundle.client_acquire();
+    client_buffer = client_acquire_blocking(bundle);
     mg::BufferID first_ready_buffer_id = client_buffer->id();
     bundle.client_release(client_buffer);
 
-    client_buffer = bundle.client_acquire();
+    client_buffer = client_acquire_blocking(bundle);
 
     // in the original bug, compositor would be given the wrong buffer here
     compositor_buffer = bundle.compositor_acquire(0 /*frameno*/);
@@ -371,11 +399,11 @@
 
         std::shared_ptr<mg::Buffer> compositor[2];
 
-        bundle.client_release(bundle.client_acquire());
+        bundle.client_release(client_acquire_blocking(bundle));
         compositor[0] = bundle.compositor_acquire(frameno);
 
         frameno++;
-        bundle.client_release(bundle.client_acquire());
+        bundle.client_release(client_acquire_blocking(bundle));
         compositor[1] = bundle.compositor_acquire(frameno);
 
         for (int i = 0; i < 20; i++)
@@ -386,7 +414,7 @@
             // One of the compositors (the oldest one) gets a new buffer...
             int oldest = i & 1;
             bundle.compositor_release(compositor[oldest]);
-            bundle.client_release(bundle.client_acquire());
+            bundle.client_release(client_acquire_blocking(bundle));
             frameno++;
             compositor[oldest] = bundle.compositor_acquire(frameno);
         }
@@ -445,7 +473,7 @@
             std::logic_error
         );
 
-        auto client = bundle.client_acquire();
+        auto client = client_acquire_blocking(bundle);
         auto snapshot = bundle.snapshot_acquire();
 
         EXPECT_EQ(compositor->id(), snapshot->id());
@@ -488,7 +516,7 @@
     {
         for (int i = 0; i < nframes; i++)
         {
-            bundle.client_release(bundle.client_acquire());
+            bundle.client_release(client_acquire_blocking(bundle));
             std::this_thread::yield();
         }
     }
@@ -499,12 +527,12 @@
         {
             bundle.allow_framedropping(false);
             for (int j = 0; j < 5; j++)
-                bundle.client_release(bundle.client_acquire());
+                bundle.client_release(client_acquire_blocking(bundle));
             std::this_thread::yield();
 
             bundle.allow_framedropping(true);
             for (int j = 0; j < 5; j++)
-                bundle.client_release(bundle.client_acquire());
+                bundle.client_release(client_acquire_blocking(bundle));
             std::this_thread::yield();
         }
     }
@@ -602,11 +630,11 @@
 
         std::shared_ptr<mg::Buffer> compositor[2];
 
-        bundle.client_release(bundle.client_acquire());
+        bundle.client_release(client_acquire_blocking(bundle));
         compositor[0] = bundle.compositor_acquire(frameno);
 
         frameno++;
-        bundle.client_release(bundle.client_acquire());
+        bundle.client_release(client_acquire_blocking(bundle));
         compositor[1] = bundle.compositor_acquire(frameno);
 
         for (int i = 0; i < 20; i++)
@@ -614,7 +642,7 @@
             // Two compositors acquired, and they're always different...
             ASSERT_NE(compositor[0]->id(), compositor[1]->id());
 
-            auto client = bundle.client_acquire();
+            auto client = client_acquire_blocking(bundle);
             ASSERT_NE(compositor[0]->id(), client->id());
             ASSERT_NE(compositor[1]->id(), client->id());
             bundle.client_release(client);
@@ -648,7 +676,7 @@
 
         for (int b = 0; b < nbuffers; b++)
         {
-            buf[b] = bundle.client_acquire();
+            buf[b] = client_acquire_blocking(bundle);
             expect[b] = buf[b]->id();
 
             for (int p = 0; p < b; p++)
@@ -660,7 +688,7 @@
 
         for (int frame = 0; frame < nframes; frame++)
         {
-            auto client = bundle.client_acquire();
+            auto client = client_acquire_blocking(bundle);
             ASSERT_EQ(expect[frame % nbuffers], client->id());
             bundle.client_release(client);
         }
@@ -739,11 +767,11 @@
             }
         });
 
-        bundle.client_release(bundle.client_acquire());
+        bundle.client_release(client_acquire_blocking(bundle));
 
         while (!done.load())
         {
-            bundle.client_release(bundle.client_acquire());
+            bundle.client_release(client_acquire_blocking(bundle));
             client_frames++;
         }
 
@@ -789,13 +817,13 @@
             }
         });
 
-        bundle.client_release(bundle.client_acquire());
+        bundle.client_release(client_acquire_blocking(bundle));
 
         while (!done.load())
         {
             sync.lock();
             sync.unlock();
-            auto buf = bundle.client_acquire();
+            auto buf = client_acquire_blocking(bundle);
             std::this_thread::sleep_for(frame_time);
             bundle.client_release(buf);
             client_frames++;
@@ -825,7 +853,7 @@
             for (int subframe = 0; subframe < 3; ++subframe)
             {
                 bundle.resize(expect_size);
-                auto client = bundle.client_acquire();
+                auto client = client_acquire_blocking(bundle);
                 ASSERT_EQ(expect_size, client->size());
                 bundle.client_release(client);
 
@@ -861,7 +889,7 @@
             height += dy;
 
             bundle.resize(new_size);
-            auto client = bundle.client_acquire();
+            auto client = client_acquire_blocking(bundle);
             history[produce] = client->id();
             ASSERT_EQ(new_size, client->size());
             bundle.client_release(client);

=== modified file 'tests/unit-tests/compositor/test_temporary_buffers.cpp'
--- tests/unit-tests/compositor/test_temporary_buffers.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/compositor/test_temporary_buffers.cpp	2014-02-10 09:00:06 +0000
@@ -52,8 +52,8 @@
     {
         using namespace testing;
 
-        ON_CALL(*mock_bundle, client_acquire())
-            .WillByDefault(Return(mock_buffer.get()));
+        ON_CALL(*mock_bundle, client_acquire(_))
+            .WillByDefault(InvokeArgument<0>(mock_buffer.get()));
         ON_CALL(*mock_bundle, compositor_acquire(_))
             .WillByDefault(Return(mock_buffer));
     }

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2014-01-13 06:55:38 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -39,6 +39,7 @@
 #include "mir_test_doubles/stub_surface_builder.h"
 #include "mir_test_doubles/stub_display_configuration.h"
 #include "mir_test_doubles/stub_buffer_allocator.h"
+#include "mir_test_doubles/null_screencast.h"
 #include "mir_test/display_config_matchers.h"
 #include "mir_test/fake_shared.h"
 #include "mir/frontend/event_sink.h"
@@ -103,7 +104,8 @@
 
         EXPECT_CALL(*mock_surface, size()).Times(AnyNumber()).WillRepeatedly(Return(geom::Size()));
         EXPECT_CALL(*mock_surface, pixel_format()).Times(AnyNumber()).WillRepeatedly(Return(MirPixelFormat()));
-        EXPECT_CALL(*mock_surface, swap_buffers(_)).Times(AnyNumber()).WillRepeatedly(SetArg<0>(mock_buffer.get()));
+        EXPECT_CALL(*mock_surface, swap_buffers(_, _)).Times(AnyNumber())
+            .WillRepeatedly(InvokeArgument<1>(mock_buffer.get()));
 
         EXPECT_CALL(*mock_surface, supports_input()).Times(AnyNumber()).WillRepeatedly(Return(true));
         EXPECT_CALL(*mock_surface, client_input_fd()).Times(AnyNumber()).WillRepeatedly(Return(testing_client_input_fd));
@@ -123,7 +125,8 @@
 
             EXPECT_CALL(*mock_surfaces[id], size()).Times(AnyNumber()).WillRepeatedly(Return(geom::Size()));
             EXPECT_CALL(*mock_surfaces[id], pixel_format()).Times(AnyNumber()).WillRepeatedly(Return(MirPixelFormat()));
-            EXPECT_CALL(*mock_surfaces[id], swap_buffers(_)).Times(AnyNumber()).WillRepeatedly(SetArg<0>(mock_buffer.get()));
+            EXPECT_CALL(*mock_surfaces[id], swap_buffers(_, _)).Times(AnyNumber())
+                .WillRepeatedly(InvokeArgument<1>(mock_buffer.get()));
 
             EXPECT_CALL(*mock_surfaces[id], supports_input()).Times(AnyNumber()).WillRepeatedly(Return(true));
             EXPECT_CALL(*mock_surfaces[id], client_input_fd()).Times(AnyNumber()).WillRepeatedly(Return(testing_client_input_fd));
@@ -183,6 +186,16 @@
     MOCK_CONST_METHOD0(egl_native_display, EGLNativeDisplayType());
 };
 
+struct StubScreencast : mtd::NullScreencast
+{
+    std::shared_ptr<mg::Buffer> capture(mf::ScreencastSessionId)
+    {
+        return mt::fake_shared(stub_buffer);
+    }
+
+    mtd::StubBuffer stub_buffer;
+};
+
 struct SessionMediatorTest : public ::testing::Test
 {
     SessionMediatorTest()
@@ -192,16 +205,17 @@
           surface_pixel_formats{mir_pixel_format_argb_8888, mir_pixel_format_xrgb_8888},
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
-          mediator{shell, graphics_platform, graphics_changer,
+          stub_screencast{std::make_shared<StubScreencast>()},
+          mediator{__LINE__, shell, graphics_platform, graphics_changer,
                    surface_pixel_formats, report,
                    std::make_shared<mtd::NullEventSink>(),
-                   resource_cache},
+                   resource_cache, stub_screencast},
           stubbed_session{std::make_shared<StubbedSession>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
         using namespace ::testing;
 
-        ON_CALL(*shell, open_session(_, _)).WillByDefault(Return(stubbed_session));
+        ON_CALL(*shell, open_session(_, _, _)).WillByDefault(Return(stubbed_session));
         ON_CALL(*shell, create_surface_for(_, _))
             .WillByDefault(WithArg<1>(Invoke(stubbed_session.get(), &StubbedSession::create_surface)));
     }
@@ -212,6 +226,7 @@
     std::vector<MirPixelFormat> const surface_pixel_formats;
     std::shared_ptr<mf::SessionMediatorReport> const report;
     std::shared_ptr<mf::ResourceCache> const resource_cache;
+    std::shared_ptr<StubScreencast> const stub_screencast;
     mf::SessionMediator mediator;
     std::shared_ptr<StubbedSession> const stubbed_session;
 
@@ -355,10 +370,10 @@
         .Times(1)
         .WillOnce(Return(mt::fake_shared(config)));
     mf::SessionMediator mediator(
-        shell, graphics_platform, mock_display,
+        __LINE__, shell, graphics_platform, mock_display,
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(),
-        resource_cache);
+        resource_cache, std::make_shared<mtd::NullScreencast>());
 
     mp::ConnectParameters connect_parameters;
     mp::Connection connection;
@@ -461,6 +476,8 @@
     mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     {
+        // AFAICS these values are stubs to set up the test condition,
+        // the exact calls here are not a *requirement* on SessionMediator
         EXPECT_CALL(*stubbed_session->mock_buffer, id())
             .WillOnce(Return(mg::BufferID{4}))
             .WillOnce(Return(mg::BufferID{4}))
@@ -519,8 +536,8 @@
      * the pre-created stubbed_session->mock_surface. Further create_surface()
      * invocations create new surfaces in stubbed_session->mock_surfaces[].
      */
-    EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(_))
-        .WillOnce(SetArg<0>(&buffer));
+    EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(_, _))
+        .WillOnce(InvokeArgument<1>(&buffer));
 
     mediator.create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
     mp::SurfaceId our_surface{surface_response.id()};
@@ -528,7 +545,7 @@
     Mock::VerifyAndClearExpectations(stubbed_session->mock_surface.get());
 
     /* Creating a new surface should not affect our surfaces' buffers */
-    EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(_)).Times(0);
+    EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(_, _)).Times(0);
     mediator.create_surface(nullptr, &surface_request, &surface_response, null_callback.get());
 
     mp::SurfaceId new_surface{surface_response.id()};
@@ -540,7 +557,7 @@
     Mock::VerifyAndClearExpectations(stubbed_session->mock_surface.get());
 
     /* Getting the next buffer of our surface should post the original */
-    EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(Eq(&buffer))).Times(1);
+    EXPECT_CALL(*stubbed_session->mock_surface, swap_buffers(Eq(&buffer), _)).Times(1);
 
     mediator.next_buffer(nullptr, &our_surface, &buffer_response, null_callback.get());
     mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
@@ -585,9 +602,10 @@
         .WillOnce(Return(mt::fake_shared(stub_display_config)));
 
     mf::SessionMediator session_mediator{
-        shell, graphics_platform, mock_display_selector,
+        __LINE__, shell, graphics_platform, mock_display_selector,
         surface_pixel_formats, report,
-        std::make_shared<mtd::NullEventSink>(), resource_cache};
+        std::make_shared<mtd::NullEventSink>(), resource_cache,
+        std::make_shared<mtd::NullScreencast>()};
 
     session_mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
@@ -620,3 +638,38 @@
 
     session_mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
 }
+
+TEST_F(SessionMediatorTest, fully_packs_buffer_for_create_screencast)
+{
+    using namespace testing;
+
+    mp::ScreencastParameters screencast_parameters;
+    mp::Screencast screencast;
+    auto const& stub_buffer = stub_screencast->stub_buffer;
+
+    EXPECT_CALL(*graphics_platform, fill_ipc_package(_, &stub_buffer));
+
+    mediator.create_screencast(nullptr, &screencast_parameters,
+                               &screencast, null_callback.get());
+
+    EXPECT_EQ(stub_buffer.id().as_uint32_t(),
+              screencast.buffer().buffer_id());
+}
+
+TEST_F(SessionMediatorTest, partially_packs_buffer_for_screencast_buffer)
+{
+    using namespace testing;
+
+    mp::ScreencastId screencast_id;
+    mp::Buffer protobuf_buffer;
+    auto const& stub_buffer = stub_screencast->stub_buffer;
+
+    EXPECT_CALL(*graphics_platform, fill_ipc_package(_, &stub_buffer))
+        .Times(0);
+
+    mediator.screencast_buffer(nullptr, &screencast_id,
+                               &protobuf_buffer, null_callback.get());
+
+    EXPECT_EQ(stub_buffer.id().as_uint32_t(),
+              protobuf_buffer.buffer_id());
+}

=== modified file 'tests/unit-tests/frontend/test_session_mediator_android.cpp'
--- tests/unit-tests/frontend/test_session_mediator_android.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/frontend/test_session_mediator_android.cpp	2014-02-10 09:00:06 +0000
@@ -32,6 +32,7 @@
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/stub_buffer_allocator.h"
+#include "mir_test_doubles/null_screencast.h"
 
 #include <gtest/gtest.h>
 
@@ -56,10 +57,10 @@
           surface_pixel_formats{mir_pixel_format_argb_8888, mir_pixel_format_xrgb_8888},
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
-          mediator{shell, graphics_platform, display_changer,
+          mediator{__LINE__, shell, graphics_platform, display_changer,
                    surface_pixel_formats, report,
                    std::make_shared<mtd::NullEventSink>(),
-                   resource_cache},
+                   resource_cache, std::make_shared<mtd::NullScreencast>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
     }

=== modified file 'tests/unit-tests/frontend/test_session_mediator_mesa.cpp'
--- tests/unit-tests/frontend/test_session_mediator_mesa.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/frontend/test_session_mediator_mesa.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -34,6 +34,7 @@
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/mock_session.h"
 #include "mir_test_doubles/stub_shell.h"
+#include "mir_test_doubles/null_screencast.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -69,10 +70,10 @@
           surface_pixel_formats{mir_pixel_format_argb_8888, mir_pixel_format_xrgb_8888},
           report{std::make_shared<mf::NullSessionMediatorReport>()},
           resource_cache{std::make_shared<mf::ResourceCache>()},
-          mediator{shell, mock_platform, display_changer,
+          mediator{__LINE__, shell, mock_platform, display_changer,
                    surface_pixel_formats, report,
                    std::make_shared<mtd::NullEventSink>(),
-                   resource_cache},
+                   resource_cache, std::make_shared<mtd::NullScreencast>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {
     }

=== modified file 'tests/unit-tests/frontend/test_socket_session.cpp'
--- tests/unit-tests/frontend/test_socket_session.cpp	2014-01-22 15:54:11 +0000
+++ tests/unit-tests/frontend/test_socket_session.cpp	2014-02-10 09:00:06 +0000
@@ -70,7 +70,7 @@
 
 struct MockProcessor : public mfd::MessageProcessor
 {
-    MOCK_METHOD1(dispatch, bool(mir::protobuf::wire::Invocation const& invocation));
+    MOCK_METHOD1(dispatch, bool(mfd::Invocation const& invocation));
 };
 }
 struct SocketSessionTest : public ::testing::Test

=== modified file 'tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp'
--- tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2014-02-10 09:00:06 +0000
@@ -236,7 +236,7 @@
 
 TEST_F(AdaptorICSTest, handle_has_version)
 {
-    int version = 96;  /* version value shared by JB and ICS */
+    int version = sizeof(ANativeWindowBuffer);  /* version value shared by JB and ICS */
     auto native_handle = alloc_adaptor->alloc_buffer(size, pf, usage);
     auto anwb = native_handle->anwb();
     EXPECT_EQ(version, anwb->common.version);

=== modified file 'tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp'
--- tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp	2014-02-10 09:00:06 +0000
@@ -101,7 +101,8 @@
 TEST_F(AndroidBufferBinding, buffer_makes_new_image_with_new_display)
 {
     using namespace testing;
-    EGLDisplay second_fake_display = (EGLDisplay) ((int)mock_egl.fake_egl_display +1);
+    EGLDisplay second_fake_display =
+        reinterpret_cast<EGLDisplay>(&second_fake_display);
 
     /* return 1st fake display */
     EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_))
@@ -121,7 +122,8 @@
 TEST_F(AndroidBufferBinding, buffer_frees_images_it_makes)
 {
     using namespace testing;
-    EGLDisplay second_fake_display = (EGLDisplay) ((int)mock_egl.fake_egl_display +1);
+    EGLDisplay second_fake_display =
+        reinterpret_cast<EGLDisplay>(&second_fake_display);
 
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(_,_))
         .Times(Exactly(2));
@@ -141,9 +143,12 @@
     using namespace testing;
 
     EGLDisplay first_fake_display = mock_egl.fake_egl_display;
-    EGLImageKHR first_fake_egl_image = (EGLImageKHR) 0x84210;
-    EGLDisplay second_fake_display = (EGLDisplay) ((int)mock_egl.fake_egl_display +1);
-    EGLImageKHR second_fake_egl_image = (EGLImageKHR) 0x84211;
+    EGLImageKHR first_fake_egl_image =
+        reinterpret_cast<EGLImageKHR>(&first_fake_egl_image);
+    EGLDisplay second_fake_display =
+        reinterpret_cast<EGLDisplay>(&second_fake_display);
+    EGLImageKHR second_fake_egl_image =
+        reinterpret_cast<EGLImageKHR>(&second_fake_egl_image);
 
     /* actual expectations */
     EXPECT_CALL(mock_egl, eglDestroyImageKHR(first_fake_display, first_fake_egl_image))
@@ -321,8 +326,10 @@
 TEST_F(AndroidBufferBinding, buffer_binding_uses_right_image_after_display_swap)
 {
     using namespace testing;
-    EGLDisplay second_fake_display = (EGLDisplay) ((int)mock_egl.fake_egl_display +1);
-    EGLImageKHR second_fake_egl_image = (EGLImageKHR) 0x84211;
+    EGLDisplay second_fake_display =
+        reinterpret_cast<EGLDisplay>(&second_fake_display);
+    EGLImageKHR second_fake_egl_image =
+        reinterpret_cast<EGLImageKHR>(&second_fake_egl_image);
 
     EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
         .Times(Exactly(1));

=== modified file 'tests/unit-tests/graphics/android/test_hwc_common_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_common_device.cpp	2014-01-21 18:09:35 +0000
+++ tests/unit-tests/graphics/android/test_hwc_common_device.cpp	2014-02-10 09:00:06 +0000
@@ -16,6 +16,7 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
+#include "mir/graphics/android/sync_fence.h"
 #include "src/platform/graphics/android/hwc_fb_device.h"
 #include "src/platform/graphics/android/hwc_device.h"
 #include "src/platform/graphics/android/hwc_layerlist.h"
@@ -58,7 +59,8 @@
     std::shared_ptr<framebuffer_device_t> const&,
     std::shared_ptr<mga::HWCVsyncCoordinator> const& coordinator)
 {
-    return std::make_shared<mga::HwcDevice>(hwc_device, coordinator);
+    auto file_ops = std::make_shared<mga::RealSyncFileOps>();
+    return std::make_shared<mga::HwcDevice>(hwc_device, coordinator, file_ops);
 }
 
 template<typename T>

=== modified file 'tests/unit-tests/graphics/android/test_hwc_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_device.cpp	2014-01-23 17:26:51 +0000
+++ tests/unit-tests/graphics/android/test_hwc_device.cpp	2014-02-10 09:00:06 +0000
@@ -16,6 +16,7 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
+#include "mir/graphics/android/sync_fence.h"
 #include "src/platform/graphics/android/framebuffer_bundle.h"
 #include "src/platform/graphics/android/hwc_device.h"
 #include "src/platform/graphics/android/hwc_layerlist.h"
@@ -35,6 +36,16 @@
 namespace mtd=mir::test::doubles;
 namespace geom=mir::geometry;
 
+namespace
+{
+struct MockFileOps : public mga::SyncFileOps
+{
+    MOCK_METHOD3(ioctl, int(int,int,void*));
+    MOCK_METHOD1(dup, int(int));
+    MOCK_METHOD1(close, int(int));
+};
+}
+
 class HwcDevice : public ::testing::Test
 {
 protected:
@@ -48,10 +59,13 @@
         mock_buffer = std::make_shared<testing::NiceMock<mtd::MockBuffer>>();
         mock_device = std::make_shared<testing::NiceMock<mtd::MockHWCComposerDevice1>>();
         mock_vsync = std::make_shared<testing::NiceMock<mtd::MockVsyncCoordinator>>();
+        mock_file_ops = std::make_shared<MockFileOps>();
 
         ON_CALL(*mock_buffer, native_buffer_handle())
             .WillByDefault(Return(mock_native_buffer));
     }
+
+    std::shared_ptr<MockFileOps> mock_file_ops;
     std::shared_ptr<mtd::MockVsyncCoordinator> mock_vsync;
     std::shared_ptr<mtd::MockHWCComposerDevice1> mock_device;
     std::shared_ptr<mtd::MockAndroidNativeBuffer> mock_native_buffer;
@@ -69,7 +83,7 @@
     EXPECT_CALL(*mock_device, set_interface(mock_device.get(),_,_))
         .Times(1);
 
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
     device.prepare_gl();
     device.post(*mock_buffer);
 
@@ -90,7 +104,7 @@
     EXPECT_CALL(*mock_device, prepare_interface(mock_device.get(), 1, _))
         .Times(1);
 
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
     device.prepare_gl();
     EXPECT_EQ(2, mock_device->display0_prepare_content.numHwLayers);
     EXPECT_EQ(-1, mock_device->display0_prepare_content.retireFenceFd);
@@ -102,7 +116,7 @@
     EXPECT_CALL(*mock_device, prepare_interface(mock_device.get(), 1, _))
         .Times(1);
 
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
     std::list<std::shared_ptr<mg::Renderable>> renderlist;
     device.prepare_gl_and_overlays(renderlist);
 
@@ -114,7 +128,7 @@
 {
     EXPECT_CALL(mock_egl, eglSwapBuffers(dpy,surf))
         .Times(1);
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
     device.gpu_render(dpy, surf);
 }
 
@@ -125,7 +139,7 @@
         .Times(1)
         .WillOnce(Return(EGL_FALSE));
 
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
 
     EXPECT_THROW({
         device.gpu_render(dpy, surf);
@@ -136,15 +150,19 @@
 {
     using namespace testing;
     int hwc_return_fence = 94;
+    int hwc_retire_fence = 74;
     mock_device->hwc_set_return_fence(hwc_return_fence);
+    mock_device->hwc_set_retire_fence(hwc_retire_fence);
 
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
 
     InSequence seq;
     EXPECT_CALL(*mock_device, set_interface(mock_device.get(), 1, _))
         .Times(1);
     EXPECT_CALL(*mock_native_buffer, update_fence(hwc_return_fence))
         .Times(1);
+    EXPECT_CALL(*mock_file_ops, close(hwc_retire_fence))
+        .Times(1);
 
     device.post(*mock_buffer);
 
@@ -161,7 +179,7 @@
 {
     using namespace testing;
 
-    mga::HwcDevice device(mock_device, mock_vsync);
+    mga::HwcDevice device(mock_device, mock_vsync, mock_file_ops);
 
     EXPECT_CALL(*mock_device, set_interface(mock_device.get(), _, _))
         .Times(1)

=== modified file 'tests/unit-tests/graphics/android/test_output_builder.cpp'
--- tests/unit-tests/graphics/android/test_output_builder.cpp	2014-01-21 18:09:35 +0000
+++ tests/unit-tests/graphics/android/test_output_builder.cpp	2014-02-10 09:00:06 +0000
@@ -122,7 +122,7 @@
         .Times(1);
 
     mga::OutputBuilder factory(
-        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     factory.create_display_device();
 }
 
@@ -143,7 +143,7 @@
         .Times(1);
 
     mga::OutputBuilder factory(
-        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     factory.create_display_device();
 }
 
@@ -161,7 +161,7 @@
         .Times(1);
 
     mga::OutputBuilder factory(
-        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     factory.create_display_device();
 }
 
@@ -182,7 +182,7 @@
         .Times(1);
 
     mga::OutputBuilder factory(
-        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     factory.create_display_device();
 }
 
@@ -201,7 +201,7 @@
 
     EXPECT_THROW({
         mga::OutputBuilder factory(
-            mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+            mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     }, std::runtime_error);
 }
 
@@ -219,7 +219,7 @@
         .Times(1);
 
     mga::OutputBuilder factory(
-        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     factory.create_display_device();
 }
 
@@ -233,6 +233,6 @@
         .Times(1);
 
     mga::OutputBuilder factory(
-        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report, false);
+        mt::fake_shared(mock_buffer_allocator),mock_resource_factory, mock_display_report);
     factory.create_display_buffer(mt::fake_shared(stub_device), gl_context);
 }

=== modified file 'tests/unit-tests/graphics/mesa/test_display_configuration.cpp'
--- tests/unit-tests/graphics/mesa/test_display_configuration.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/graphics/mesa/test_display_configuration.cpp	2014-02-10 09:00:06 +0000
@@ -289,7 +289,7 @@
     /* Test body */
     auto display = create_display(create_platform());
 
-    auto conf = display->configuration();
+    std::shared_ptr<mg::DisplayConfiguration> conf = display->configuration();
     auto const& kms_conf = std::static_pointer_cast<mgm::KMSDisplayConfiguration>(conf);
 
     size_t output_count{0};
@@ -332,7 +332,7 @@
     /* Test body */
     auto display = create_display(create_platform());
 
-    auto conf = display->configuration();
+    std::shared_ptr<mg::DisplayConfiguration> conf = display->configuration();
     auto const& kms_conf = std::static_pointer_cast<mgm::KMSDisplayConfiguration>(conf);
 
     EXPECT_THROW({

=== modified file 'tests/unit-tests/scene/test_application_session.cpp'
--- tests/unit-tests/scene/test_application_session.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/scene/test_application_session.cpp	2014-02-10 09:00:06 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as