Merge into development-branch : nested-passthrough : Code : Mir

Reviewer	Review Type	Date Requested	Status
Daniel van Vugt		2016-09-30	Approve on 2016-10-10
Cemil Azizoglu (community)			Approve on 2016-10-07
Mir CI Bot	continuous-integration		Approve on 2016-10-06
Review via email: mp+307315@code.launchpad.net

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-09-30:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1862/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-09-30:

#

grr, merge madness

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-09-30:

#

FAILED: Continuous integration, rev:3733
https://mir-jenkins.ubuntu.com/job/mir-ci/1863/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2358/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2421
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2413
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2413
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2413
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2387/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2387/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2387/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2387/console
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2387/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2387
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2387/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2387/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1863/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-09-30:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1865/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-09-30:

#

FAILED: Continuous integration, rev:3737
https://mir-jenkins.ubuntu.com/job/mir-ci/1866/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2362/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2425
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2417
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2417
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2417
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2391/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2391/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2391/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2391/console
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2391/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2391
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2391/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2391/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1866/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-10-04:

#

bug 1612012

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-10-04:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1884/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-10-04:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1886/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-10-04:

#

hmm, seems different than the logged bug, investigating further

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

For the measurements, we can measure latency externally using mirvanity. Although I suspect we don't expect any reduction in latency here(?).

I think CPU and GPU load is also something we aim to reduce but bug 1540207 suggests that we won't see that on desktop. So maybe try looking at CPU/GPU usage on mobile for some positive measurements.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

OK, I've just done some fresh high-speed camera testing with mirvanity. Confirmed there is no reduction in latency here. Nesting still introduces two extra frames of lag (triple buffers):

Trunk: 64ms
This branch: 64ms
Trunk (nested): 97ms
This branch (nested): 97ms

But that's OK. Latency reductions will come later with the client-side vsync work I'm doing...

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

Oh. Is this relevant?

[2016-10-05 11:22:54.841327] <ERROR> mirclient: Caught exception at client library boundary (in mir_buffer_egl_image_parameters): /home/dan/bzr/mir/tmp.nested/src/platforms/mesa/client/client_buffer.cpp(175): Throw in function virtual void mir::client::mesa::ClientBuffer::egl_image_creation_parameters(EGLenum*, void**, EGLint**)
Dynamic exception type: boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<std::invalid_argument> >
std::exception::what: not implemented yet

[2016-10-05 11:22:54.841628] <ERROR> mirclient: Caught exception at client library boundary (in mir_buffer_egl_image_parameters): /home/dan/bzr/mir/tmp.nested/src/platforms/mesa/client/client_buffer.cpp(175): Throw in function virtual void mir::client::mesa::ClientBuffer::egl_image_creation_parameters(EGLenum*, void**, EGLint**)
Dynamic exception type: boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<std::invalid_argument> >
std::exception::what: not implemented yet

Revision history for this message

Daniel van Vugt (vanvugt) on 2016-10-05:

#

review: Needs Information

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

Looks like that exception is fixed in:
lp:~kdub/mir/mesa-clientbuffer-eglimage-mapping

Revision history for this message

Daniel van Vugt (vanvugt) on 2016-10-05:

#

review: Abstain

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

Win! Merging lp:~kdub/mir/mesa-clientbuffer-eglimage-mapping with this one gets the nesting lag down from 97ms to 64ms. Thus after you combine both branches the nesting lag is eliminated!

review: Approve

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

Bugger. Found a regression in fullscreen framedropping clients (mir_demo_client_egltriangle -n -f). On trunk it renders at 1200 FPS, but with this branch (and the other one) we are bound to 60 FPS, which is bad for games and other apps that rely on swap interval 0 not blocking.

Although a similar bug 1369763 has existed on android for at least two years. We should avoid breaking desktop as well.

review: Needs Fixing

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

Actually fixing bug 1369763 is possibly a prerequisite for my future lower latency work. So we really need to fix it everywhere.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

Also, since this branch doesn't actually do what the label says until you combine it with lp:~kdub/mir/mesa-clientbuffer-eglimage-mapping, it might be an idea to prereq that.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-05:

#

OK, a few issues, so to summarise:

(0) Please prerequisite lp:~kdub/mir/mesa-clientbuffer-eglimage-mapping to make this branch work on desktop.

(1) Needs Fixing: Framedropping pass-through clients are incorrectly bound to 60 FPS.

(2) Needs Fixing: My nested server got stuck in an infinite loop on shutdown when testing this branch, but that bug might have originated elsewhere?...

[2016-10-05 15:49:42.260127] <ERROR> Mesa/NativeSurface: Caught exception at Mir/EGL driver boundary (in advance_buffer): Dynamic exception type: std::logic_error
std::exception::what: state was not valid

[2016-10-05 15:49:42.262044] <ERROR> Mesa/NativeSurface: Caught exception at Mir/EGL driver boundary (in advance_buffer): Dynamic exception type: std::logic_error
std::exception::what: state was not valid

[2016-10-05 15:49:42.264824] <ERROR> Mesa/NativeSurface: Caught exception at Mir/EGL driver boundary (in advance_buffer): Dynamic exception type: std::logic_error
std::exception::what: state was not valid

Looks similar to bug 1630230.

review: Needs Fixing

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-10-06:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1905/rebuild

PASSED: Continuous integration, rev:3740
https://mir-jenkins.ubuntu.com/job/mir-ci/1905/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/2418
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2481
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2473
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2473
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2473
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2447
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2447/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2447
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2447/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2447
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2447/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2447
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2447/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2447
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2447/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2447
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2447/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1905/rebuild

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-10-06:

#

with the 60fps degradation, still needs investigation. The fix pushed might have fixed the shutdown problem, and did fix CI. Still investigating a situation with the io threads and shutdown, that I've only seen in the acceptance tests, but should be fixed anyways.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-10-06:

#

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1906/rebuild

PASSED: Continuous integration, rev:3741
https://mir-jenkins.ubuntu.com/job/mir-ci/1906/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/2419
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2482
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2474
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2474
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2474
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2448
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2448/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2448
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2448/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2448
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2448/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2448
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2448/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2448
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2448/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2448
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2448/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1906/rebuild

review: Approve (continuous-integration)

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-07:

#

(0) I'm trying to solve this by landing the other branch today, before this one. That way this landing will actually be the revision in which nested passthrough also started working.

(1) I don't mind too much if this bug remains unresolved briefly. Since I started looking at how NBS does swap intervals yesterday I now realize we have a couple of other existing bugs in this area to fix already. So making that three bugs instead of two isn't a major problem. Especially if multiple bugs get resolved all at once.

(2) Can't reproduce that error now. Thanks.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-07:

#

(3) Just worth noting; a pixel format with alpha may well be able to pass-through but in some cases (at least always on desktop) will be rejected by bypass:

+bool mgn::MirClientHostConnection::supports_passthrough()
467 +{
468 + auto buffer = create_buffer(mg::BufferProperties(geom::Size{1, 1} , mir_pixel_format_abgr_8888, mg::BufferUsage::software));

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2016-10-07:

#

LGTM... Looking forward to more complete performance numbers.

review: Approve

Revision history for this message

Kevin DuBois (kdub) wrote on 2016-10-07:

#

@Daniel
for (1) the issue is that the client is swapinterval0, and the chain representing that client in the host server is operating with 'swapinterval1'. The spare buffers quickly all end up getting stuck in the host's queue, instead of returning from the host on new submissions.

I'm plumbing up a way for the host and the client to agree on swapinterval at the moment. will restack on that branch, and then we don't have to have the issue.

for (3) can probably add this in a subsequent branch.

@Cemil
Will propose updates to the latency suite to accommodate nested passthrough, hopefully before the sprint.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2016-10-10:

#

(3) I wonder if there ever might be some future platform which can't pass-through non-bypassable buffers (abgr). Doesn't seem to be important yet but it wouldn't hurt us to remove all doubt and probe using xbgr only.

Cemil:
You won't get more accurate (or encouraging) performance numbers than my above measurements. Although sadly mirvanity only runs on desktop (no Video4Linux support on Android!?).

review: Approve

Mir

Merge lp:~kdub/mir/nested-passthrough into lp:mir

Commit message

Description of the change

Preview Diff

Subscribers

 === modified file 'include/test/mir_test_framework/any_surface.h'
 --- include/test/mir_test_framework/any_surface.h	2016-01-29 08:18:22 +0000
 +++ include/test/mir_test_framework/any_surface.h	2016-10-06 14:43:17 +0000
@@ -20,10 +20,12 @@
  #define MIR_TEST_FRAMEWORK_ANY_SURFACE_H_
  #include "mir_toolkit/mir_client_library.h"
++#include "mir/geometry/size.h"
  namespace mir_test_framework
+ {
--MirSurface *make_any_surface(MirConnection *connection);
++MirSurface* make_any_surface(MirConnection *connection);
++MirSurface* make_surface(MirConnection *connection, mir::geometry::Size size, MirPixelFormat format);
+ }
  #endif // MIR_TEST_FRAMEWORK_ANY_SURFACE_H_
 === modified file 'include/test/mir_test_framework/headless_display_buffer_compositor_factory.h'
 --- include/test/mir_test_framework/headless_display_buffer_compositor_factory.h	2016-09-19 04:16:15 +0000
 +++ include/test/mir_test_framework/headless_display_buffer_compositor_factory.h	2016-10-06 14:43:17 +0000
@@ -22,10 +22,15 @@
  namespace mir_test_framework
+ {
++class PassthroughTracker;
  struct HeadlessDisplayBufferCompositorFactory : mir::compositor::DisplayBufferCompositorFactory
+ {
++    HeadlessDisplayBufferCompositorFactory();
++    HeadlessDisplayBufferCompositorFactory(std::shared_ptr<PassthroughTracker> const& tracker);
      std::unique_ptr<mir::compositor::DisplayBufferCompositor> create_compositor_for(
          mir::graphics::DisplayBuffer& display_buffer) override;
++private:
++    std::shared_ptr<PassthroughTracker> const tracker;
  };
+ }
  #endif /* MIR_TEST_FRAMEWORK_HEADLESS_DISPLAY_BUFFER_COMPOSITOR_FACTORY_H_ */
 === modified file 'include/test/mir_test_framework/headless_nested_server_runner.h'
 --- include/test/mir_test_framework/headless_nested_server_runner.h	2016-01-29 08:18:22 +0000
 +++ include/test/mir_test_framework/headless_nested_server_runner.h	2016-10-06 14:43:17 +0000
@@ -20,13 +20,25 @@
  #define MIR_TEST_FRAMEWORK_HEADLESS_NESTED_SERVER_RUNNER_H_
  #include "mir_test_framework/async_server_runner.h"
++#include <atomic>
  namespace mir_test_framework
+ {
++struct PassthroughTracker
++{
++    bool wait_for_passthrough_frames(size_t num_frames, std::chrono::milliseconds ms);
++    void note_passthrough();
++private:
++    std::mutex mutex;
++    std::condition_variable cv;
++    size_t num_passthrough;
++};
++
  class HeadlessNestedServerRunner : public AsyncServerRunner
+ {
  public:
      HeadlessNestedServerRunner(std::string const& connect_string);
++    std::shared_ptr<PassthroughTracker> const passthrough_tracker;
  };
+ }
 === modified file 'src/client/atomic_callback.h'
 --- src/client/atomic_callback.h	2016-06-06 12:49:18 +0000
 +++ src/client/atomic_callback.h	2016-10-06 14:43:17 +0000
@@ -44,20 +44,20 @@
      void set_callback(std::function<void(Args...)> const& fn)
+     {
--        std::lock_guard<std::mutex> lk(guard);
++        std::lock_guard<std::recursive_mutex> lk(guard);
          callback = fn;
+     }
      void operator()(Args&&... args) const
+     {
--        std::lock_guard<std::mutex> lk(guard);
++        std::lock_guard<std::recursive_mutex> lk(guard);
          callback(std::forward<Args>(args)...);
+     }
  private:
--    std::mutex mutable guard;
++    std::recursive_mutex mutable guard;
      std::function<void(Args...)> callback;
  };
+ }
 === modified file 'src/client/mir_buffer_api.cpp'
 --- src/client/mir_buffer_api.cpp	2016-09-30 07:03:28 +0000
 +++ src/client/mir_buffer_api.cpp	2016-10-06 14:43:17 +0000
@@ -49,11 +49,13 @@
      MIR_LOG_UNCAUGHT_EXCEPTION(ex);
+ }
++void ignore(MirBuffer*, void*){}
  void mir_buffer_release(MirBuffer* b)
  try
+ {
      mir::require(b);
      auto buffer = reinterpret_cast<mcl::MirBuffer*>(b);
++    buffer->set_callback(ignore, nullptr);
      auto connection = buffer->allocating_connection();
      connection->release_buffer(buffer);
+ }
 === modified file 'src/server/compositor/buffer_map.cpp'
 --- src/server/compositor/buffer_map.cpp	2016-06-24 17:32:47 +0000
 +++ src/server/compositor/buffer_map.cpp	2016-10-06 14:43:17 +0000
@@ -53,11 +53,13 @@
          std::unique_lock<decltype(mutex)> lk(mutex);
          auto buffer = allocator->alloc_buffer(properties);
          buffers[buffer->id()] = {buffer, Owner::client};
--        sink->add_buffer(*buffer);
++        if (auto s = sink.lock())
++            s->add_buffer(*buffer);
          return buffer->id();
      } catch (std::exception& e)
+     {
--        sink->error_buffer(properties, e.what());
++        if (auto s = sink.lock())
++            s->error_buffer(properties, e.what());
          throw;
+     }
+ }
@@ -66,7 +68,8 @@
+ {
      std::unique_lock<decltype(mutex)> lk(mutex);
      auto it = checked_buffers_find(id, lk);
--    sink->remove_buffer(*it->second.buffer);
++    if (auto s = sink.lock())
++        s->remove_buffer(*it->second.buffer);
      buffers.erase(it);
+ }
@@ -79,7 +82,8 @@
          auto buffer = it->second.buffer;
          it->second.owner = Owner::client;
          lk.unlock();
--        sink->update_buffer(*buffer);
++        if (auto s = sink.lock())
++            s->update_buffer(*buffer);
+     }
+ }
 === modified file 'src/server/compositor/buffer_map.h'
 --- src/server/compositor/buffer_map.h	2016-06-02 05:33:50 +0000
 +++ src/server/compositor/buffer_map.h	2016-10-06 14:43:17 +0000
@@ -58,7 +58,9 @@
      Map buffers;
      Map::iterator checked_buffers_find(graphics::BufferID, std::unique_lock<std::mutex> const&);
--    std::shared_ptr<frontend::BufferSink> const sink;
++    //would be better to schedule the async buffer callbacks in the ipc subsystem,
++    //instead of driving from within the compositor threads (LP: #1395421)
++    std::weak_ptr<frontend::BufferSink> const sink;
      std::shared_ptr<graphics::GraphicBufferAllocator> const allocator;
  };
+ }
 === modified file 'src/server/graphics/nested/buffer.cpp'
 --- src/server/graphics/nested/buffer.cpp	2016-09-22 18:17:43 +0000
 +++ src/server/graphics/nested/buffer.cpp	2016-10-06 14:43:17 +0000
@@ -181,7 +181,7 @@
  std::shared_ptr<mg::NativeBuffer> mgn::Buffer::native_buffer_handle() const
+ {
--    return nullptr;
++    return buffer;
+ }
  geom::Size mgn::Buffer::size() const
 === modified file 'src/server/graphics/nested/host_connection.h'
 --- src/server/graphics/nested/host_connection.h	2016-09-22 16:27:13 +0000
 +++ src/server/graphics/nested/host_connection.h	2016-10-06 14:43:17 +0000
@@ -77,6 +77,7 @@
      virtual void set_input_event_callback(std::function<void(MirEvent const&, mir::geometry::Rectangle const&)> const& cb) = 0;
      virtual void emit_input_event(MirEvent const& event, mir::geometry::Rectangle const& source_frame) = 0;
      virtual std::shared_ptr<NativeBuffer> create_buffer(graphics::BufferProperties const&) = 0;
++    virtual bool supports_passthrough() = 0;
  protected:
      HostConnection() = default;
 === modified file 'src/server/graphics/nested/host_surface_spec.h'
 --- src/server/graphics/nested/host_surface_spec.h	2016-09-08 18:32:45 +0000
 +++ src/server/graphics/nested/host_surface_spec.h	2016-10-06 14:43:17 +0000
@@ -19,6 +19,7 @@
  #ifndef MIR_GRAPHICS_NESTED_HOST_SURFACE_SPEC_H_
  #define MIR_GRAPHICS_NESTED_HOST_SURFACE_SPEC_H_
++#include "mir_toolkit/client_types.h"
  #include "mir/geometry/size.h"
  #include "mir/geometry/displacement.h"
@@ -36,6 +37,7 @@
      virtual ~HostSurfaceSpec() = default;
      virtual void add_chain(HostChain&, geometry::Displacement disp, geometry::Size size) = 0;
      virtual void add_stream(HostStream&, geometry::Displacement disp) = 0;
++    virtual MirSurfaceSpec* handle() = 0;
  protected:
      HostSurfaceSpec() = default;
      HostSurfaceSpec(HostSurfaceSpec const&) = delete;
 === modified file 'src/server/graphics/nested/ipc_operations.h'
 --- src/server/graphics/nested/ipc_operations.h	2016-09-13 12:40:23 +0000
 +++ src/server/graphics/nested/ipc_operations.h	2016-10-06 14:43:17 +0000
@@ -33,8 +33,8 @@
  public:
      IpcOperations(std::shared_ptr<graphics::PlatformIpcOperations> const& host_operations);
--    void pack_buffer(BufferIpcMessage& message, Buffer const& buffer, BufferIpcMsgType msg_type) const override;
--    void unpack_buffer(BufferIpcMessage& message, Buffer const& buffer) const override;
++    void pack_buffer(BufferIpcMessage& message, graphics::Buffer const& buffer, BufferIpcMsgType msg_type) const override;
++    void unpack_buffer(BufferIpcMessage& message, graphics::Buffer const& buffer) const override;
      std::shared_ptr<PlatformIPCPackage> connection_ipc_package() override;
      PlatformOperationMessage platform_operation(
          unsigned int const opcode, PlatformOperationMessage const& message) override;
 === modified file 'src/server/graphics/nested/mir_client_host_connection.cpp'
 --- src/server/graphics/nested/mir_client_host_connection.cpp	2016-10-04 11:56:53 +0000
 +++ src/server/graphics/nested/mir_client_host_connection.cpp	2016-10-06 14:43:17 +0000
@@ -20,11 +20,16 @@
  #include "host_surface.h"
  #include "host_stream.h"
  #include "host_chain.h"
++#include "host_surface_spec.h"
++#include "native_buffer.h"
  #include "mir_toolkit/mir_client_library.h"
  #include "mir_toolkit/mir_buffer.h"
++#include "mir_toolkit/mir_buffer_private.h"
++#include "mir_toolkit/mir_presentation_chain.h"
  #include "mir/raii.h"
  #include "mir/graphics/platform_operation_message.h"
  #include "mir/graphics/cursor_image.h"
++#include "mir/graphics/buffer.h"
  #include "mir/input/device.h"
  #include "mir/input/device_capability.h"
  #include "mir/input/pointer_configuration.h"
@@ -38,9 +43,11 @@
  #include <algorithm>
  #include <stdexcept>
++#include <condition_variable>
  #include <cstring>
++namespace geom = mir::geometry;
  namespace mg = mir::graphics;
  namespace mgn = mir::graphics::nested;
  namespace mi = mir::input;
@@ -114,8 +121,9 @@
          mir_surface_release_sync(mir_surface);
+     }
--    void apply_spec(mgn::HostSurfaceSpec&) override
++    void apply_spec(mgn::HostSurfaceSpec& spec) override
+     {
++        mir_surface_apply_spec(mir_surface, spec.handle());
+     }
      EGLNativeWindowType egl_native_window() override
@@ -477,18 +485,197 @@
      return std::make_unique<MirClientHostStream>(mir_connection, properties);
+ }
++struct Chain : mgn::HostChain
++{
++    Chain(MirConnection* connection) :
++        chain(mir_connection_create_presentation_chain_sync(connection))
++    {
++    }
++    ~Chain()
++    {
++        mir_presentation_chain_release(chain);
++    }
++
++    void submit_buffer(mgn::NativeBuffer& buffer)
++    {
++        mir_presentation_chain_submit_buffer(chain, buffer.client_handle());
++    }
++
++    MirPresentationChain* handle()
++    {
++        return chain;
++    }
++private:
++    MirPresentationChain* chain;
++};
++
  std::unique_ptr<mgn::HostChain> mgn::MirClientHostConnection::create_chain() const
+ {
--    BOOST_THROW_EXCEPTION(std::runtime_error("not implemented yet"));
++    return std::make_unique<Chain>(mir_connection);
++}
++
++namespace
++{
++class HostBuffer : public mgn::NativeBuffer
++{
++public:
++    HostBuffer(MirConnection* mir_connection, mg::BufferProperties const& properties)
++    {
++        mir_connection_allocate_buffer(
++            mir_connection,
++            properties.size.width.as_int(),
++            properties.size.height.as_int(),
++            properties.format,
++            (properties.usage == mg::BufferUsage::hardware) ? mir_buffer_usage_hardware : mir_buffer_usage_software,
++            buffer_available, this);
++        std::unique_lock<std::mutex> lk(mut);
++        cv.wait(lk, [&]{ return handle; });
++        if (!mir_buffer_is_valid(handle))
++        {
++            mir_buffer_release(handle);
++            BOOST_THROW_EXCEPTION(std::runtime_error("could not allocate MirBuffer"));
++        }
++    }
++    ~HostBuffer()
++    {
++        mir_buffer_release(handle);
++    }
++
++    void sync(MirBufferAccess access, std::chrono::nanoseconds ns) override
++    {
++        mir_buffer_wait_for_access(handle, access, ns.count());
++    }
++
++    MirBuffer* client_handle() const override
++    {
++        return handle;
++    }
++
++    MirGraphicsRegion get_graphics_region() override
++    {
++        return mir_buffer_get_graphics_region(handle, mir_read_write);
++    }
++
++    geom::Size size() const override
++    {
++        return { mir_buffer_get_width(handle), mir_buffer_get_height(handle) };
++    }
++
++    MirPixelFormat format() const override
++    {
++        return mir_buffer_get_pixel_format(handle);
++    }
++
++    std::tuple<EGLenum, EGLClientBuffer, EGLint*> egl_image_creation_hints() const override
++    {
++        EGLenum type;
++        EGLClientBuffer client_buffer = nullptr;;
++        EGLint* attrs = nullptr;
++        mir_buffer_egl_image_parameters(handle, &type, &client_buffer, &attrs);
++
++        return std::tuple<EGLenum, EGLClientBuffer, EGLint*>{type, client_buffer, attrs};
++    }
++
++    static void buffer_available(MirBuffer* buffer, void* context)
++    {
++        auto host_buffer = static_cast<HostBuffer*>(context);
++        host_buffer->available(buffer);
++    }
++
++    void available(MirBuffer* buffer)
++    {
++        std::unique_lock<std::mutex> lk(mut);
++        if (!handle)
++        {
++            handle = buffer;
++            cv.notify_all();
++        }
++
++        auto g = f;
++        lk.unlock();
++        if (g)
++            g();
++    }
++
++    void on_ownership_notification(std::function<void()> const& fn) override
++    {
++        std::unique_lock<std::mutex> lk(mut);
++        f = fn;
++    }
++
++    MirBufferPackage* package() const override
++    {
++       return mir_buffer_get_buffer_package(handle);
++    }
++
++    void set_fence(mir::Fd fd) override
++    {
++        mir_buffer_associate_fence(handle, fd, mir_read_write);
++    }
++
++    mir::Fd fence() const override
++    {
++        return mir::Fd{mir::IntOwnedFd{mir_buffer_get_fence(handle)}};
++    }
++
++private:
++    std::function<void()> f;
++    MirBuffer* handle = nullptr;
++    std::mutex mut;
++    std::condition_variable cv;
++};
++
++class SurfaceSpec : public mgn::HostSurfaceSpec
++{
++public:
++    SurfaceSpec(MirConnection* connection) :
++        spec(mir_connection_create_spec_for_changes(connection))
++    {
++    }
++
++    ~SurfaceSpec()
++    {
++        mir_surface_spec_release(spec);
++    }
++
++    void add_chain(mgn::HostChain& chain, geom::Displacement disp, geom::Size size) override
++    {
++        mir_surface_spec_add_presentation_chain(
++            spec, size.width.as_int(), size.height.as_int(),
++            disp.dx.as_int(), disp.dy.as_int(), chain.handle());
++    }
++
++    void add_stream(mgn::HostStream& stream, geom::Displacement disp) override
++    {
++        mir_surface_spec_add_buffer_stream(spec, disp.dx.as_int(), disp.dy.as_int(), stream.handle());
++    }
++
++    MirSurfaceSpec* handle() override
++    {
++        return spec;
++    }
++private:
++    MirSurfaceSpec* spec;
++};
+ }
  std::shared_ptr<mgn::NativeBuffer> mgn::MirClientHostConnection::create_buffer(
--    mg::BufferProperties const&)
++    mg::BufferProperties const& properties)
+ {
--    BOOST_THROW_EXCEPTION(std::runtime_error("not implemented yet"));
++    return std::make_shared<HostBuffer>(mir_connection, properties);
+ }
  std::unique_ptr<mgn::HostSurfaceSpec> mgn::MirClientHostConnection::create_surface_spec()
+ {
--    BOOST_THROW_EXCEPTION(std::runtime_error("not implemented yet"));
++    return std::make_unique<SurfaceSpec>(mir_connection);
++}
++
++bool mgn::MirClientHostConnection::supports_passthrough()
++{
++    auto buffer = create_buffer(mg::BufferProperties(geom::Size{1, 1} , mir_pixel_format_abgr_8888, mg::BufferUsage::software));
++
++    auto hints = buffer->egl_image_creation_hints();
++    if (std::get<1>(hints) == nullptr && std::get<2>(hints) == nullptr)
++        return false;
++    return true;
+ }
 === modified file 'src/server/graphics/nested/mir_client_host_connection.h'
 --- src/server/graphics/nested/mir_client_host_connection.h	2016-10-04 11:56:53 +0000
 +++ src/server/graphics/nested/mir_client_host_connection.h	2016-10-06 14:43:17 +0000
@@ -86,6 +86,7 @@
      void set_input_event_callback(std::function<void(MirEvent const&, mir::geometry::Rectangle const&)> const& cb) override;
      void emit_input_event(MirEvent const& cb, mir::geometry::Rectangle const& source_frame) override;
      std::shared_ptr<NativeBuffer> create_buffer(graphics::BufferProperties const&) override;
++    bool supports_passthrough() override;
  private:
      void update_input_config(UniqueInputConfig input_config);
 === modified file 'src/server/graphics/nested/native_buffer.h'
 --- src/server/graphics/nested/native_buffer.h	2016-09-30 12:26:56 +0000
 +++ src/server/graphics/nested/native_buffer.h	2016-10-06 14:43:17 +0000
@@ -43,7 +43,6 @@
      virtual ~NativeBuffer() = default;
      virtual void sync(MirBufferAccess, std::chrono::nanoseconds) = 0;
      virtual MirBuffer* client_handle() const = 0;
--    virtual MirNativeBuffer* get_native_handle() = 0;
      virtual MirGraphicsRegion get_graphics_region() = 0;
      virtual geometry::Size size() const = 0;
      virtual MirPixelFormat format() const = 0;
 === modified file 'src/server/graphics/nested/platform.cpp'
 --- src/server/graphics/nested/platform.cpp	2016-07-19 20:56:18 +0000
 +++ src/server/graphics/nested/platform.cpp	2016-10-06 14:43:17 +0000
@@ -19,10 +19,16 @@
  #include "platform.h"
  #include "host_connection.h"
  #include "display.h"
++#include "buffer.h"
++#include "native_buffer.h"
++#include "ipc_operations.h"
  #include "mir/shared_library.h"
  #include "mir/graphics/graphic_buffer_allocator.h"
  #include "mir/graphics/display.h"
  #include "mir/graphics/platform_ipc_operations.h"
++#include "mir/graphics/buffer_ipc_message.h"
++#include "mir/graphics/platform_ipc_operations.h"
++#include "mir/graphics/platform_operation_message.h"
  namespace mg = mir::graphics;
  namespace mgn = mir::graphics::nested;
@@ -39,9 +45,53 @@
+ {
+ }
++namespace
++{
++class BufferAllocator : public mg::GraphicBufferAllocator
++{
++public:
++    BufferAllocator(
++        std::shared_ptr<mgn::HostConnection> const& connection,
++        std::shared_ptr<mg::GraphicBufferAllocator> const& guest_allocator) :
++        connection(connection),
++        guest_allocator(guest_allocator)
++    {
++    }
++
++    std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const& buffer_properties) override
++    {
++        if ((buffer_properties.size.width >= mir::geometry::Width{480}) &&
++            (buffer_properties.size.height >= mir::geometry::Height{480}))
++        {
++            return std::make_shared<mgn::Buffer>(connection, buffer_properties);
++        }
++        else
++        {
++            return guest_allocator->alloc_buffer(buffer_properties);
++        }
++    }
++
++    std::vector<MirPixelFormat> supported_pixel_formats() override
++    {
++        return guest_allocator->supported_pixel_formats();
++    }
++
++private:
++    std::shared_ptr<mgn::HostConnection> const connection;
++    std::shared_ptr<mg::GraphicBufferAllocator> const guest_allocator;
++};
++}
++
  mir::UniqueModulePtr<mg::GraphicBufferAllocator> mgn::Platform::create_buffer_allocator()
+ {
--    return guest_platform->create_buffer_allocator();
++    if (connection->supports_passthrough())
++    {
++        return mir::make_module_ptr<BufferAllocator>(connection, guest_platform->create_buffer_allocator());
++    }
++    else
++    {
++        return guest_platform->create_buffer_allocator();
++    }
+ }
  mir::UniqueModulePtr<mg::Display> mgn::Platform::create_display(
@@ -58,5 +108,5 @@
  mir::UniqueModulePtr<mg::PlatformIpcOperations> mgn::Platform::make_ipc_operations() const
+ {
--    return guest_platform->make_ipc_operations();
++    return mir::make_module_ptr<mgn::IpcOperations>(guest_platform->make_ipc_operations());
+ }
 === modified file 'tests/acceptance-tests/test_nested_mir.cpp'
 --- tests/acceptance-tests/test_nested_mir.cpp	2016-09-28 14:07:37 +0000
 +++ tests/acceptance-tests/test_nested_mir.cpp	2016-10-06 14:43:17 +0000
@@ -640,6 +640,13 @@
  struct ClientWithAPaintedSurface : virtual Client
+ {
++    ClientWithAPaintedSurface(NestedMirRunner& nested_mir, geom::Size size, MirPixelFormat format) :
++        Client(nested_mir),
++        surface(mtf::make_surface(connection, size, format))
++    {
++        mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface));
++    }
++
      ClientWithAPaintedSurface(NestedMirRunner& nested_mir) :
          Client(nested_mir),
          surface(mtf::make_any_surface(connection))
@@ -1504,3 +1511,13 @@
      EXPECT_TRUE(host_config_change.raised());
      Mock::VerifyAndClearExpectations(&display);
+ }
++
++TEST_F(NestedServer, uses_passthrough_when_surface_size_is_appropriate)
++{
++    using namespace std::chrono_literals;
++    NestedMirRunner nested_mir{new_connection()};
++    nested_mir.wait_until_ready();
++    ClientWithAPaintedSurface client(
++        nested_mir, display_geometry.front().size, mir_pixel_format_xbgr_8888);
++    EXPECT_TRUE(nested_mir.passthrough_tracker->wait_for_passthrough_frames(1, 5s));
++}
 === modified file 'tests/include/mir/test/doubles/stub_client_buffer.h'
 --- tests/include/mir/test/doubles/stub_client_buffer.h	2016-09-30 07:03:28 +0000
 +++ tests/include/mir/test/doubles/stub_client_buffer.h	2016-10-06 14:43:17 +0000
@@ -85,7 +85,12 @@
      void set_fence(Fd, MirBufferAccess) override {}
      Fd get_fence() const override { return mir::Fd(mir::Fd::invalid); }
      bool wait_fence(MirBufferAccess, std::chrono::nanoseconds) override { return true; }
--    void egl_image_creation_parameters(EGLenum*, EGLClientBuffer*, EGLint**) {}
++    void egl_image_creation_parameters(EGLenum*, EGLClientBuffer*, EGLint** attrs)
++    {
++        static EGLint image_attrs[] = { EGL_NONE };
++        if (attrs)
++            *attrs = image_attrs;
++    }
      std::shared_ptr<MirBufferPackage> const package_;
      geometry::Size size_;
 === modified file 'tests/include/mir/test/doubles/stub_host_connection.h'
 --- tests/include/mir/test/doubles/stub_host_connection.h	2016-09-23 16:50:05 +0000
 +++ tests/include/mir/test/doubles/stub_host_connection.h	2016-10-06 14:43:17 +0000
@@ -156,9 +156,14 @@
+         {
              void add_chain(graphics::nested::HostChain&, geometry::Displacement, geometry::Size) override {}
              void add_stream(graphics::nested::HostStream&, geometry::Displacement) override {}
++            MirSurfaceSpec* handle() { return nullptr; }
          };
          return std::make_unique<NullSpec>();
+     }
++    bool supports_passthrough()
++    {
++        return true;
++    }
  };
  struct MockHostConnection : StubHostConnection
 === modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
 --- tests/integration-tests/test_buffer_scheduling.cpp	2016-09-28 00:41:48 +0000
 +++ tests/integration-tests/test_buffer_scheduling.cpp	2016-10-06 14:43:17 +0000
@@ -588,9 +588,8 @@
      BufferScheduling()
+     {
          ipc = std::make_shared<StubIpcSystem>();
--        map = std::make_shared<mc::BufferMap>(
--                std::make_shared<StubEventSink>(ipc),
--                std::make_shared<mtd::StubBufferAllocator>());
++        sink = std::make_shared<StubEventSink>(ipc);
++        map = std::make_shared<mc::BufferMap>(sink, std::make_shared<mtd::StubBufferAllocator>());
          auto submit_stream = std::make_shared<mc::Stream>(
              drop_policy,
              map,
@@ -648,6 +647,7 @@
      mcl::ClientBufferDepository depository{mt::fake_shared(client_buffer_factory), nbuffers};
      std::shared_ptr<mc::BufferStream> stream;
      std::shared_ptr<StubIpcSystem> ipc;
++    std::shared_ptr<mf::BufferSink> sink;
      std::unique_ptr<ProducerSystem> producer;
      std::unique_ptr<ConsumerSystem> consumer;
      std::unique_ptr<ConsumerSystem> second_consumer;
 === modified file 'tests/mir_test_framework/any_surface.cpp'
 --- tests/mir_test_framework/any_surface.cpp	2016-08-23 03:44:55 +0000
 +++ tests/mir_test_framework/any_surface.cpp	2016-10-06 14:43:17 +0000
@@ -32,10 +32,16 @@
  MirSurface* mtf::make_any_surface(MirConnection *connection)
+ {
++    return mtf::make_surface(connection, mir::geometry::Size{width, height}, format);
++}
++
++MirSurface* mtf::make_surface(
++    MirConnection *connection, mir::geometry::Size size, MirPixelFormat f)
++{
      using namespace std::literals::string_literals;
      auto spec = mir_connection_create_spec_for_normal_surface(connection,
--        width, height, format);
++        size.width.as_int(), size.height.as_int(), f);
      auto surface = mir_surface_create_sync(spec);
      mir_surface_spec_release(spec);
 === modified file 'tests/mir_test_framework/headless_display_buffer_compositor_factory.cpp'
 --- tests/mir_test_framework/headless_display_buffer_compositor_factory.cpp	2016-09-19 06:09:48 +0000
 +++ tests/mir_test_framework/headless_display_buffer_compositor_factory.cpp	2016-10-06 14:43:17 +0000
@@ -17,6 +17,7 @@
   */
  #include "mir_test_framework/headless_display_buffer_compositor_factory.h"
++#include "mir_test_framework/headless_nested_server_runner.h"
  #include "mir/renderer/gl/render_target.h"
  #include "mir/graphics/display_buffer.h"
  #include "mir/compositor/display_buffer_compositor.h"
@@ -30,13 +31,27 @@
  namespace mc = mir::compositor;
  namespace geom = mir::geometry;
++mtf::HeadlessDisplayBufferCompositorFactory::HeadlessDisplayBufferCompositorFactory() :
++    tracker(nullptr)
++{
++}
++
++mtf::HeadlessDisplayBufferCompositorFactory::HeadlessDisplayBufferCompositorFactory(
++    std::shared_ptr<PassthroughTracker> const& tracker) :
++    tracker(tracker)
++{
++}
++
  std::unique_ptr<mir::compositor::DisplayBufferCompositor>
  mtf::HeadlessDisplayBufferCompositorFactory::create_compositor_for(mg::DisplayBuffer& db)
+ {
      struct HeadlessDBC : mir::compositor::DisplayBufferCompositor
+     {
--        HeadlessDBC(mg::DisplayBuffer& db) :
++        HeadlessDBC(
++            mg::DisplayBuffer& db,
++            std::shared_ptr<mtf::PassthroughTracker> const& tracker) :
              db(db),
++            tracker(tracker),
              render_target(dynamic_cast<mrg::RenderTarget*>(
                  db.native_display_buffer()))
+         {
@@ -73,7 +88,11 @@
+         {
              auto renderlist = filter(seq, db.view_area());
              if (db.overlay(renderlist))
++            {
++                if (tracker)
++                    tracker->note_passthrough();
                  return;
++            }
              // Invoke GL renderer specific functions if the DisplayBuffer supports them
              if (render_target)
@@ -87,7 +106,8 @@
                  render_target->swap_buffers();
+         }
          mg::DisplayBuffer& db;
++        std::shared_ptr<PassthroughTracker> const tracker;
          mrg::RenderTarget* const render_target;
      };
--    return std::make_unique<HeadlessDBC>(db);
++    return std::make_unique<HeadlessDBC>(db, tracker);
+ }
 === modified file 'tests/mir_test_framework/headless_nested_server_runner.cpp'
 --- tests/mir_test_framework/headless_nested_server_runner.cpp	2016-09-19 04:16:15 +0000
 +++ tests/mir_test_framework/headless_nested_server_runner.cpp	2016-10-06 14:43:17 +0000
@@ -22,12 +22,26 @@
  namespace mtf = mir_test_framework;
--mtf::HeadlessNestedServerRunner::HeadlessNestedServerRunner(std::string const& connect_string)
++mtf::HeadlessNestedServerRunner::HeadlessNestedServerRunner(std::string const& connect_string) :
++    passthrough_tracker(std::make_shared<mtf::PassthroughTracker>())
+ {
      add_to_environment("MIR_SERVER_PLATFORM_GRAPHICS_LIB", mtf::server_platform("graphics-dummy.so").c_str());
      add_to_environment("MIR_SERVER_HOST_SOCKET", connect_string.c_str());
--    server.override_the_display_buffer_compositor_factory([]
++    server.override_the_display_buffer_compositor_factory([this]
+     {
--        return std::make_shared<mtf::HeadlessDisplayBufferCompositorFactory>();
++        return std::make_shared<mtf::HeadlessDisplayBufferCompositorFactory>(passthrough_tracker);
      });
+ }
++
++void mtf::PassthroughTracker::note_passthrough()
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    num_passthrough++;
++    cv.notify_all();
++}
++
++bool mtf::PassthroughTracker::wait_for_passthrough_frames(size_t nframes, std::chrono::milliseconds ms)
++{
++    std::unique_lock<std::mutex> lk(mutex);
++    return cv.wait_for(lk, ms, [&] { return num_passthrough >= nframes; } );
++}
 === modified file 'tests/mir_test_framework/headless_test.cpp'
 --- tests/mir_test_framework/headless_test.cpp	2016-09-19 04:16:15 +0000
 +++ tests/mir_test_framework/headless_test.cpp	2016-10-06 14:43:17 +0000
@@ -34,7 +34,7 @@
      add_to_environment("MIR_SERVER_PLATFORM_GRAPHICS_LIB", mtf::server_platform("graphics-dummy.so").c_str());
      add_to_environment("MIR_SERVER_PLATFORM_INPUT_LIB", mtf::server_platform("input-stub.so").c_str());
      add_to_environment("MIR_SERVER_ENABLE_KEY_REPEAT", "false");
--    server.override_the_display_buffer_compositor_factory([]
++    server.override_the_display_buffer_compositor_factory([this]
+     {
          return std::make_shared<mtf::HeadlessDisplayBufferCompositorFactory>();
      });
 === modified file 'tests/unit-tests/compositor/test_client_buffers.cpp'
 --- tests/unit-tests/compositor/test_client_buffers.cpp	2016-06-24 17:32:47 +0000
 +++ tests/unit-tests/compositor/test_client_buffers.cpp	2016-10-06 14:43:17 +0000
@@ -59,11 +59,11 @@
  struct ClientBuffers : public Test
+ {
--    testing::NiceMock<mtd::MockEventSink> mock_sink;
++    std::shared_ptr<mtd::MockEventSink> mock_sink = std::make_shared<testing::NiceMock<mtd::MockEventSink>>();
      mg::BufferProperties properties{geom::Size{42,43}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware};
      MockBufferAllocator mock_allocator;
      StubBufferAllocator stub_allocator;
--    mc::BufferMap map{mt::fake_shared(mock_sink), mt::fake_shared(stub_allocator)};
++    mc::BufferMap map{mock_sink, mt::fake_shared(stub_allocator)};
  };
  TEST_F(ClientBuffers, sends_full_buffer_on_allocation)
@@ -71,8 +71,8 @@
      auto stub_buffer = std::make_shared<mtd::StubBuffer>();
      EXPECT_CALL(mock_allocator, alloc_buffer(Ref(properties)))
          .WillOnce(Return(stub_buffer));
--    EXPECT_CALL(mock_sink, add_buffer(Ref(*stub_buffer)));
--    mc::BufferMap map{mt::fake_shared(mock_sink), mt::fake_shared(mock_allocator)};
++    EXPECT_CALL(*mock_sink, add_buffer(Ref(*stub_buffer)));
++    mc::BufferMap map{mock_sink, mt::fake_shared(mock_allocator)};
      EXPECT_THAT(map.add_buffer(properties), Eq(stub_buffer->id()));
+ }
@@ -107,7 +107,7 @@
      ASSERT_THAT(stub_allocator.map, SizeIs(1));
      ASSERT_THAT(stub_allocator.ids, SizeIs(1));
      auto buffer = map[stub_allocator.ids[0]];
--    EXPECT_CALL(mock_sink, update_buffer(Ref(*buffer)));
++    EXPECT_CALL(*mock_sink, update_buffer(Ref(*buffer)));
      map.send_buffer(stub_allocator.ids[0]);
+ }
@@ -118,7 +118,7 @@
      ASSERT_THAT(stub_allocator.ids, SizeIs(1));
      auto buffer = map[stub_allocator.ids[0]];
--    EXPECT_CALL(mock_sink, remove_buffer(Ref(*buffer)));
++    EXPECT_CALL(*mock_sink, remove_buffer(Ref(*buffer)));
      map.remove_buffer(stub_allocator.ids[0]);
      map.send_buffer(stub_allocator.ids[0]);
+ }
@@ -126,7 +126,7 @@
  TEST_F(ClientBuffers, can_remove_buffer_from_send_callback)
+ {
      map.add_buffer(properties);
--    ON_CALL(mock_sink, update_buffer(_))
++    ON_CALL(*mock_sink, update_buffer(_))
          .WillByDefault(Invoke(
          [&] (mg::Buffer& buffer)
+         {
@@ -138,7 +138,7 @@
  TEST_F(ClientBuffers, ignores_unknown_receive)
+ {
--    EXPECT_CALL(mock_sink, add_buffer(_))
++    EXPECT_CALL(*mock_sink, add_buffer(_))
          .Times(1);
      map.add_buffer(properties);
      map.remove_buffer(stub_allocator.ids[0]);
@@ -150,8 +150,8 @@
      std::string error_msg = "a reason";
      EXPECT_CALL(mock_allocator, alloc_buffer(Ref(properties)))
          .WillOnce(Throw(std::runtime_error(error_msg)));
--    EXPECT_CALL(mock_sink, error_buffer(properties, StrEq(error_msg)));
--    mc::BufferMap map{mt::fake_shared(mock_sink), mt::fake_shared(mock_allocator)};
++    EXPECT_CALL(*mock_sink, error_buffer(properties, StrEq(error_msg)));
++    mc::BufferMap map{mock_sink, mt::fake_shared(mock_allocator)};
      EXPECT_THROW({
          map.add_buffer(properties);
      }, std::runtime_error);
 === modified file 'tests/unit-tests/platforms/nested/test_buffer.cpp'
 --- tests/unit-tests/platforms/nested/test_buffer.cpp	2016-09-30 12:26:56 +0000
 +++ tests/unit-tests/platforms/nested/test_buffer.cpp	2016-10-06 14:43:17 +0000
@@ -208,6 +208,7 @@
      EXPECT_CALL(mock_egl, eglGetCurrentDisplay());
      EXPECT_CALL(mock_egl, eglGetCurrentContext());
++    EXPECT_CALL(mock_egl, eglCreateImageKHR(_,_,_,_,_));
      EXPECT_CALL(*client_buffer, sync(mir_read, _));
      EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, _));
 === modified file 'tests/unit-tests/platforms/nested/test_ipc_operations.cpp'
 --- tests/unit-tests/platforms/nested/test_ipc_operations.cpp	2016-09-30 12:53:35 +0000
 +++ tests/unit-tests/platforms/nested/test_ipc_operations.cpp	2016-10-06 14:43:17 +0000
@@ -47,7 +47,6 @@
  public:
      void sync(MirBufferAccess, std::chrono::nanoseconds) override {}
      MirBuffer* client_handle() const override { return nullptr; }
--    MirNativeBuffer* get_native_handle() override { return nullptr; }
      MirGraphicsRegion get_graphics_region() override
+     {
          return MirGraphicsRegion { 0, 0, 0, mir_pixel_format_invalid, nullptr };
 === modified file 'tests/unit-tests/platforms/nested/test_nested_display_buffer.cpp'
 --- tests/unit-tests/platforms/nested/test_nested_display_buffer.cpp	2016-09-30 12:53:35 +0000
 +++ tests/unit-tests/platforms/nested/test_nested_display_buffer.cpp	2016-10-06 14:43:17 +0000
@@ -122,7 +122,6 @@
      geom::Size size() const override { return {}; }
      MirPixelFormat format() const override { return mir_pixel_format_invalid; }
      void on_ownership_notification(std::function<void()> const& f) override { fn = f; }
--    MirNativeBuffer* get_native_handle() override { return nullptr; }
      MirBufferPackage* package() const override { return nullptr; }
      mir::Fd fence() const override { return mir::Fd{mir::Fd::invalid}; }
      void set_fence(mir::Fd) override {}