Merge lp:~mir-team/mir/0.18.3 into lp:mir/0.18

[Kevin DuBois]

MP for Temporary silo to address lp: #1517205

MP for Temporary silo to address lp: #1517205

Unmerged revisions

3197. By Kevin DuBois on 2016-01-25

add quirk to clear fence for another device during FB GL rendering

3196. By Kevin DuBois on 2016-01-25

disable eglsync on mx4 due to driver problem necessitating gles3.0

3195. By Kevin DuBois on 2016-01-25

bump changelog to 0.18.2

3194. By Kevin DuBois on 2016-01-25

reintroduce sync fences

=== modified file 'debian/changelog'
--- debian/changelog	2016-01-18 18:06:23 +0000
+++ debian/changelog	2016-01-25 17:04:59 +0000
@@ -1,4 +1,10 @@
-mir (0.18.1-0ubuntu1) UNRELEASED; urgency=medium
+mir (0.18.2-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Add egl sync fences for devices that need it. (LP: #1517205) 
+
+ -- Kevin DuBois <[e-mail]>  Mon, 25 Jan 2016 09:58:43 -0500
+
+mir (0.18.1-0ubuntu1) xenial; urgency=medium
 
   * New upstream release 0.18.1 (https://launchpad.net/mir/+milestone/0.18.1)
     - No ABI changes. Bug fix release only.

=== modified file 'include/renderers/gl/mir/renderer/gl/texture_source.h'
--- include/renderers/gl/mir/renderer/gl/texture_source.h	2015-12-11 12:22:15 +0000
+++ include/renderers/gl/mir/renderer/gl/texture_source.h	2016-01-25 17:04:59 +0000
@@ -26,12 +26,22 @@
 namespace gl
 {
 
+//FIXME: (kdub) we're not hiding the differences in texture upload approaches between our platforms
+//       very well with this interface.
 class TextureSource
 {
 public:
     virtual ~TextureSource() = default;
 
+    // \warning deprecated, provided for convenience and legacy transition.
+    //will call bind() and then secure_for_render()
     virtual void gl_bind_to_texture() = 0;
+    //Uploads texture.
+    virtual void bind() = 0;
+    //add synchronization points to the command stream to ensure resources
+    //are present during the draw. Will not upload texture.
+    //should be called if an already uploaded texture is reused.
+    virtual void secure_for_render() = 0;
 
 protected:
     TextureSource() = default;

=== modified file 'src/common/graphics/android/CMakeLists.txt'
--- src/common/graphics/android/CMakeLists.txt	2015-12-11 12:22:15 +0000
+++ src/common/graphics/android/CMakeLists.txt	2016-01-25 17:04:59 +0000
@@ -1,5 +1,7 @@
 include_directories(SYSTEM ${LIBHARDWARE_INCLUDE_DIRS})
 include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/3rd_party/android-deps)
+include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/include/platform)
+include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/src/include/platform)
 
 add_definitions( -DANDROID )
 

=== modified file 'src/common/graphics/android/android_native_buffer.cpp'
--- src/common/graphics/android/android_native_buffer.cpp	2015-12-11 12:22:15 +0000
+++ src/common/graphics/android/android_native_buffer.cpp	2016-01-25 17:04:59 +0000
@@ -17,14 +17,17 @@
  */
 
 #include "mir/graphics/android/android_native_buffer.h"
+#include "mir/graphics/egl_sync_fence.h"
 
 namespace mga=mir::graphics::android;
 
 mga::AndroidNativeBuffer::AndroidNativeBuffer(
     std::shared_ptr<ANativeWindowBuffer> const& anwb,
+    std::shared_ptr<CommandStreamSync> const& cmdstream_sync,
     std::shared_ptr<Fence> const& fence,
     BufferAccess access)
-    : fence(fence),
+    : cmdstream_sync(cmdstream_sync),
+      fence(fence),
       access(access),
       native_window_buffer(anwb)
 {
@@ -58,3 +61,14 @@
 {
     return fence->copy_native_handle();
 }
+
+void mga::AndroidNativeBuffer::lock_for_gpu()
+{
+    cmdstream_sync->raise();
+}
+
+void mga::AndroidNativeBuffer::wait_for_unlock_by_gpu()
+{
+    using namespace std::chrono;
+    cmdstream_sync->wait_for(duration_cast<nanoseconds>(seconds(2)));
+}

=== modified file 'src/gl/recently_used_cache.cpp'
--- src/gl/recently_used_cache.cpp	2015-12-11 12:22:15 +0000
+++ src/gl/recently_used_cache.cpp	2016-01-25 17:04:59 +0000
@@ -27,6 +27,7 @@
 namespace mg = mir::graphics;
 namespace mgl = mir::gl;
 namespace geom = mir::geometry;
+namespace mrgl = mir::renderer::gl;
 
 std::shared_ptr<mgl::Texture> mgl::RecentlyUsedCache::load(mg::Renderable const& renderable)
 {
@@ -35,18 +36,18 @@
     auto& texture = textures[renderable.id()];
     texture.texture->bind();
 
+    auto const texture_source = dynamic_cast<mrgl::TextureSource*>(buffer->native_buffer_base());
+    if (!texture_source)
+        BOOST_THROW_EXCEPTION(std::logic_error("Buffer does not support GL rendering"));
+
     if ((texture.last_bound_buffer != buffer_id) || (!texture.valid_binding))
     {
-        auto const texture_source =
-            dynamic_cast<mir::renderer::gl::TextureSource*>(
-                    buffer->native_buffer_base());
-        if (!texture_source)
-            BOOST_THROW_EXCEPTION(std::logic_error("Buffer does not support GL rendering"));
-
-        texture_source->gl_bind_to_texture();
+        texture_source->bind();
         texture.resource = buffer;
         texture.last_bound_buffer = buffer_id;
     }
+    texture_source->secure_for_render();
+
     texture.valid_binding = true;
     texture.used = true;
 

=== modified file 'src/include/common/mir/graphics/android/android_native_buffer.h'
--- src/include/common/mir/graphics/android/android_native_buffer.h	2015-12-11 12:22:15 +0000
+++ src/include/common/mir/graphics/android/android_native_buffer.h	2016-01-25 17:04:59 +0000
@@ -27,6 +27,7 @@
 {
 namespace graphics
 {
+class CommandStreamSync;
 namespace android
 {
 class Fence;
@@ -35,6 +36,7 @@
 {
     AndroidNativeBuffer(
         std::shared_ptr<ANativeWindowBuffer> const& handle,
+        std::shared_ptr<CommandStreamSync> const& cmdstream_sync,
         std::shared_ptr<Fence> const& fence,
         BufferAccess fence_access);
 
@@ -45,7 +47,11 @@
     void ensure_available_for(BufferAccess);
     void update_usage(NativeFence& merge_fd, BufferAccess);
 
+    void lock_for_gpu();
+    void wait_for_unlock_by_gpu();
+
 private:
+    std::shared_ptr<CommandStreamSync> cmdstream_sync;
     std::shared_ptr<Fence> fence;
     BufferAccess access;
     std::shared_ptr<ANativeWindowBuffer> native_window_buffer;

=== modified file 'src/include/common/mir/graphics/android/native_buffer.h'
--- src/include/common/mir/graphics/android/native_buffer.h	2015-12-11 12:22:15 +0000
+++ src/include/common/mir/graphics/android/native_buffer.h	2016-01-25 17:04:59 +0000
@@ -53,6 +53,9 @@
     virtual void ensure_available_for(android::BufferAccess intent) = 0;
     virtual void update_usage(android::NativeFence& fence, android::BufferAccess current_usage) = 0;
 
+    virtual void lock_for_gpu() = 0;
+    virtual void wait_for_unlock_by_gpu() = 0;
+
 protected:
     NativeBuffer() = default;
     NativeBuffer(NativeBuffer const&) = delete;

=== modified file 'src/platform/symbols.map'
--- src/platform/symbols.map	2015-12-11 12:22:15 +0000
+++ src/platform/symbols.map	2016-01-25 17:04:59 +0000
@@ -219,6 +219,7 @@
     vtable?for?mir::graphics::EventHandlerRegister;
     vtable?for?mir::graphics::GLConfig;
     vtable?for?mir::graphics::GLContext;
+    vtable?for?mir::graphics::NullCommandSync;
     vtable?for?mir::graphics::GraphicBufferAllocator;
     vtable?for?mir::graphics::Platform;
     vtable?for?mir::graphics::PlatformIpcOperations;
@@ -237,6 +238,19 @@
     mir::graphics::blue_channel_depth*;
     mir::graphics::contains_alpha*;
     mir::graphics::EGLExtensions::EGLExtensions*;
+    mir::graphics::EGLSyncExtensions::EGLSyncExtensions*;
+    mir::graphics::CommandStreamSync::?CommandStreamSync*;
+    mir::graphics::CommandStreamSync::CommandStreamSync*;
+    mir::graphics::CommandStreamSync::CommandStreamSync*;
+    mir::graphics::CommandStreamSync::operator*;
+    mir::graphics::NullCommandSync::?NullCommandSync*;
+    mir::graphics::NullCommandSync::NullCommandSync*;
+    mir::graphics::NullCommandSync::NullCommandSync*;
+    mir::graphics::NullCommandSync::operator*;
+    mir::graphics::EGLSyncFence::?EGLSyncFence*;
+    mir::graphics::EGLSyncFence::EGLSyncFence*;
+    mir::graphics::EGLSyncFence::EGLSyncFence*;
+    mir::graphics::EGLSyncFence::operator*;
     mir::graphics::EGLContextStore::?EGLContextStore*;
     mir::graphics::EGLContextStore::EGLContextStore*;
     mir::graphics::EGLContextStore::EGLContextStore*;

=== modified file 'src/platforms/android/client/CMakeLists.txt'
--- src/platforms/android/client/CMakeLists.txt	2015-12-11 12:22:15 +0000
+++ src/platforms/android/client/CMakeLists.txt	2016-01-25 17:04:59 +0000
@@ -1,6 +1,8 @@
 include_directories(${client_common_include_dirs})
 include_directories(SYSTEM ${LIBHARDWARE_INCLUDE_DIRS})
 include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/3rd_party/android-deps)
+include_directories(${CMAKE_SOURCE_DIR}/include/platform)
+include_directories(${CMAKE_SOURCE_DIR}/src/include/platform)
 
 add_definitions(-DANDROID)
 
@@ -35,6 +37,7 @@
   mirclient
   client_platform_common
   mirsharedandroid-static
+  mirplatform
   ${LIBHARDWARE_LIBRARIES}
 )
 

=== modified file 'src/platforms/android/client/gralloc_registrar.cpp'
--- src/platforms/android/client/gralloc_registrar.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/client/gralloc_registrar.cpp	2016-01-25 17:04:59 +0000
@@ -18,6 +18,7 @@
 
 #include "mir/graphics/android/android_native_buffer.h"
 #include "mir/graphics/android/sync_fence.h"
+#include "mir/graphics/egl_sync_fence.h"
 #include "gralloc_registrar.h"
 #include "mir/client_buffer.h"
 
@@ -82,7 +83,8 @@
     anwb->usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;
     anwb->handle = handle.get();
 
-    return std::make_shared<mga::AndroidNativeBuffer>(anwb, fence, mga::BufferAccess::read);
+    auto sync = std::make_shared<mg::NullCommandSync>(); //no need for eglsync client side
+    return std::make_shared<mga::AndroidNativeBuffer>(anwb, sync, fence, mga::BufferAccess::read);
 }
 }
 std::shared_ptr<mg::NativeBuffer> mcla::GrallocRegistrar::register_buffer(

=== modified file 'src/platforms/android/server/CMakeLists.txt'
--- src/platforms/android/server/CMakeLists.txt	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/CMakeLists.txt	2016-01-25 17:04:59 +0000
@@ -43,6 +43,7 @@
   hwc_fallback_gl_renderer.cpp
   ipc_operations.cpp
   hwc_blanking_control.cpp
+  egl_sync_factory.cpp
 )
 
 add_library(mirplatformgraphicsandroid SHARED

=== modified file 'src/platforms/android/server/android_alloc_adaptor.cpp'
--- src/platforms/android/server/android_alloc_adaptor.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/android_alloc_adaptor.cpp	2016-01-25 17:04:59 +0000
@@ -20,7 +20,9 @@
 #include "mir/graphics/android/android_native_buffer.h"
 #include "mir/graphics/android/sync_fence.h"
 #include "mir/graphics/android/android_format_conversion-inl.h"
+#include "mir/graphics/egl_sync_fence.h"
 #include "android_alloc_adaptor.h"
+#include "cmdstream_sync_factory.h"
 #include "device_quirks.h"
 
 #include <boost/throw_exception.hpp>
@@ -48,10 +50,13 @@
 };
 }
 
-mga::AndroidAllocAdaptor::AndroidAllocAdaptor(std::shared_ptr<struct alloc_device_t> const& alloc_device,
-    std::shared_ptr<DeviceQuirks> const& quirks)
-    : alloc_dev(alloc_device),
-      quirks(quirks)
+mga::AndroidAllocAdaptor::AndroidAllocAdaptor(
+    std::shared_ptr<struct alloc_device_t> const& alloc_device,
+    std::shared_ptr<CommandStreamSyncFactory> const& sync_factory,
+    std::shared_ptr<DeviceQuirks> const& quirks) :
+    alloc_dev(alloc_device),
+    sync_factory(sync_factory),
+    quirks(quirks)
 {
 }
 
@@ -94,7 +99,9 @@
     anwb->format = format;
     anwb->usage = usage_flag;
 
-    return std::make_shared<mga::AndroidNativeBuffer>(anwb, fence, mga::BufferAccess::read);
+    return std::make_shared<mga::AndroidNativeBuffer>(anwb,
+        sync_factory->create_command_stream_sync(),
+        fence, mga::BufferAccess::read);
 }
 
 int mga::AndroidAllocAdaptor::convert_to_android_usage(BufferUsage usage)

=== modified file 'src/platforms/android/server/android_alloc_adaptor.h'
--- src/platforms/android/server/android_alloc_adaptor.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/android_alloc_adaptor.h	2016-01-25 17:04:59 +0000
@@ -31,12 +31,15 @@
 namespace android
 {
 class DeviceQuirks;
+class CommandStreamSyncFactory;
 
 class AndroidAllocAdaptor : public GraphicAllocAdaptor
 {
 public:
-    explicit AndroidAllocAdaptor(std::shared_ptr<struct alloc_device_t> const& alloc_device,
-                                 std::shared_ptr<DeviceQuirks> const& quirks);
+    explicit AndroidAllocAdaptor(
+        std::shared_ptr<struct alloc_device_t> const& alloc_device,
+        std::shared_ptr<CommandStreamSyncFactory> const& cmdstream_sync_factory,
+        std::shared_ptr<DeviceQuirks> const& quirks);
     std::shared_ptr<NativeBuffer> alloc_buffer(geometry::Size,
             MirPixelFormat, BufferUsage usage);
 
@@ -44,6 +47,7 @@
 
 private:
     std::shared_ptr<struct alloc_device_t> alloc_dev;
+    std::shared_ptr<CommandStreamSyncFactory> const sync_factory;
     std::shared_ptr<DeviceQuirks> const quirks;
     int convert_to_android_usage(BufferUsage usage);
 };

=== modified file 'src/platforms/android/server/android_buffer_allocator.cpp'
--- src/platforms/android/server/android_buffer_allocator.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/android_buffer_allocator.cpp	2016-01-25 17:04:59 +0000
@@ -19,12 +19,14 @@
 
 #include "mir/graphics/platform.h"
 #include "mir/graphics/egl_extensions.h"
+#include "mir/graphics/egl_sync_fence.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir/graphics/android/sync_fence.h"
 #include "mir/graphics/android/android_native_buffer.h"
 #include "android_graphic_buffer_allocator.h"
 #include "android_alloc_adaptor.h"
 #include "buffer.h"
+#include "cmdstream_sync_factory.h"
 #include "device_quirks.h"
 
 #include <boost/throw_exception.hpp>
@@ -50,8 +52,11 @@
 
 }
 
-mga::AndroidGraphicBufferAllocator::AndroidGraphicBufferAllocator(std::shared_ptr<DeviceQuirks> const& quirks)
-    : egl_extensions(std::make_shared<mg::EGLExtensions>())
+mga::AndroidGraphicBufferAllocator::AndroidGraphicBufferAllocator(
+    std::shared_ptr<CommandStreamSyncFactory> const& cmdstream_sync_factory,
+    std::shared_ptr<DeviceQuirks> const& quirks)
+    : egl_extensions(std::make_shared<mg::EGLExtensions>()),
+    cmdstream_sync_factory(cmdstream_sync_factory)
 {
     int err;
 
@@ -70,7 +75,7 @@
     std::shared_ptr<struct alloc_device_t> alloc_dev_ptr(
         alloc_dev,
         quirks->gralloc_cannot_be_closed_safely() ? null_alloc_dev_deleter : alloc_dev_deleter);
-    alloc_device = std::shared_ptr<mga::GraphicAllocAdaptor>(new AndroidAllocAdaptor(alloc_dev_ptr, quirks));
+    alloc_device = std::shared_ptr<mga::GraphicAllocAdaptor>(new AndroidAllocAdaptor(alloc_dev_ptr, cmdstream_sync_factory, quirks));
 }
 
 std::shared_ptr<mg::Buffer> mga::AndroidGraphicBufferAllocator::alloc_buffer(
@@ -89,9 +94,10 @@
         [](ANativeWindowBuffer* buffer){ buffer->common.decRef(&buffer->common); });
     anwb->common.incRef(&anwb->common);
 
+    //TODO: we should have an android platform function for accessing the fence.
     auto native_handle = std::make_shared<mga::AndroidNativeBuffer>(
         native_window_buffer,
-        //TODO: we should have an android platform function for accessing the fence.
+        cmdstream_sync_factory->create_command_stream_sync(),
         std::make_shared<mga::SyncFence>(std::make_shared<mga::RealSyncFileOps>(), mir::Fd()),
         mga::BufferAccess::read);
     return std::make_unique<Buffer>(

=== modified file 'src/platforms/android/server/android_graphic_buffer_allocator.h'
--- src/platforms/android/server/android_graphic_buffer_allocator.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/android_graphic_buffer_allocator.h	2016-01-25 17:04:59 +0000
@@ -39,11 +39,14 @@
 
 class GraphicAllocAdaptor;
 class DeviceQuirks;
+class CommandStreamSyncFactory;
 
 class AndroidGraphicBufferAllocator: public GraphicBufferAllocator, public graphics::GraphicBufferAllocator
 {
 public:
-    AndroidGraphicBufferAllocator(std::shared_ptr<DeviceQuirks> const& quirks);
+    AndroidGraphicBufferAllocator(
+        std::shared_ptr<CommandStreamSyncFactory> const& cmdstream_sync_factory,
+        std::shared_ptr<DeviceQuirks> const& quirks);
 
     std::shared_ptr<graphics::Buffer> alloc_buffer(
         graphics::BufferProperties const& buffer_properties) override;
@@ -61,6 +64,7 @@
     const hw_module_t    *hw_module;
     std::shared_ptr<GraphicAllocAdaptor> alloc_device;
     std::shared_ptr<EGLExtensions> const egl_extensions;
+    std::shared_ptr<CommandStreamSyncFactory> const cmdstream_sync_factory;
 };
 
 }

=== modified file 'src/platforms/android/server/buffer.cpp'
--- src/platforms/android/server/buffer.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/buffer.cpp	2016-01-25 17:04:59 +0000
@@ -74,6 +74,18 @@
 void mga::Buffer::gl_bind_to_texture()
 {
     std::unique_lock<std::mutex> lk(content_lock);
+    bind(lk);
+    secure_for_render(lk);
+}
+
+void mga::Buffer::bind()
+{
+    std::unique_lock<std::mutex> lk(content_lock);
+    bind(lk);
+}
+
+void mga::Buffer::bind(std::unique_lock<std::mutex> const&)
+{
     native_buffer->ensure_available_for(mga::BufferAccess::read);
 
     DispContextPair current
@@ -113,10 +125,6 @@
     }
 
     egl_extensions->glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
-
-    //TODO: we should make use of the android egl fence extension here to update the fence.
-    //      if the extension is not available, we should pass out a token that the user
-    //      will have to keep until the completion of the gl draw
 }
 
 std::shared_ptr<mg::NativeBuffer> mga::Buffer::native_buffer_handle() const
@@ -196,3 +204,14 @@
 {
     return this;
 }
+
+void mga::Buffer::secure_for_render()
+{
+    std::unique_lock<std::mutex> lk(content_lock);
+    secure_for_render(lk);
+}
+
+void mga::Buffer::secure_for_render(std::unique_lock<std::mutex> const&)
+{
+    native_buffer->lock_for_gpu();
+}

=== modified file 'src/platforms/android/server/buffer.h'
--- src/platforms/android/server/buffer.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/buffer.h	2016-01-25 17:04:59 +0000
@@ -56,6 +56,10 @@
     geometry::Stride stride() const override;
     MirPixelFormat pixel_format() const override;
     void gl_bind_to_texture() override;
+    void bind() override;
+    void secure_for_render() override;
+
+
     //note, you will get the native representation of an android buffer, including
     //the fences associated with the buffer. You must close these fences
     std::shared_ptr<NativeBuffer> native_buffer_handle() const override;
@@ -66,6 +70,8 @@
     NativeBufferBase* native_buffer_base() override;
 
 private:
+    void bind(std::unique_lock<std::mutex> const&);
+    void secure_for_render(std::unique_lock<std::mutex> const&);
     gralloc_module_t const* hw_module;
 
     typedef std::pair<EGLDisplay, EGLContext> DispContextPair;

=== added file 'src/platforms/android/server/cmdstream_sync_factory.h'
--- src/platforms/android/server/cmdstream_sync_factory.h	1970-01-01 00:00:00 +0000
+++ src/platforms/android/server/cmdstream_sync_factory.h	2016-01-25 17:04:59 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_CMDSTREAM_SYNC_FACTORY_H_
+#define MIR_GRAPHICS_ANDROID_CMDSTREAM_SYNC_FACTORY_H_
+
+#include <memory>
+namespace mir
+{
+namespace graphics
+{
+class CommandStreamSync;
+namespace android
+{
+class CommandStreamSyncFactory
+{
+public:
+    virtual ~CommandStreamSyncFactory() = default;
+    virtual std::unique_ptr<CommandStreamSync> create_command_stream_sync() = 0;
+protected:
+    CommandStreamSyncFactory() = default;
+    CommandStreamSyncFactory(CommandStreamSyncFactory const&) = delete;
+    CommandStreamSyncFactory& operator=(CommandStreamSyncFactory const&) = delete;
+};
+
+class EGLSyncFactory : public CommandStreamSyncFactory
+{
+    std::unique_ptr<CommandStreamSync> create_command_stream_sync() override;
+};
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_CMDSTREAM_SYNC_FACTORY_H_ */

=== modified file 'src/platforms/android/server/device_quirks.cpp'
--- src/platforms/android/server/device_quirks.cpp	2015-11-30 18:29:57 +0000
+++ src/platforms/android/server/device_quirks.cpp	2016-01-25 17:04:59 +0000
@@ -62,7 +62,7 @@
 
 bool clear_fb_context_fence_for(std::string const& device_name)
 {
-    return device_name == "krillin" || device_name == "mx4" || device_name == "manta";
+    return device_name == "krillin" || device_name == "mx4" || device_name == "manta" || device_name =="Aquaris_M10_FHD";
 }
 
 }
@@ -107,6 +107,12 @@
     return clear_fb_context_fence_;
 }
 
+bool mga::DeviceQuirks::working_egl_sync() const
+{
+    //FIXME: this really should be all powervr devices.
+    return device_name != "mx4";
+}
+
 void mga::DeviceQuirks::add_options(boost::program_options::options_description& config)
 {
     config.add_options()

=== modified file 'src/platforms/android/server/device_quirks.h'
--- src/platforms/android/server/device_quirks.h	2015-11-30 12:36:04 +0000
+++ src/platforms/android/server/device_quirks.h	2016-01-25 17:04:59 +0000
@@ -64,6 +64,7 @@
     bool gralloc_cannot_be_closed_safely() const;
     int aligned_width(int width) const;
     bool clear_fb_context_fence() const;
+    bool working_egl_sync() const;
 
     static void add_options(boost::program_options::options_description& config);
 

=== modified file 'src/platforms/android/server/display_buffer.cpp'
--- src/platforms/android/server/display_buffer.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/display_buffer.cpp	2016-01-25 17:04:59 +0000
@@ -98,6 +98,9 @@
 void mga::DisplayBuffer::swap_buffers()
 {
     layer_list->update_list({}, offset_from_origin);
+    //HWC 1.0 cannot call eglSwapBuffers() on the display context
+    if (display_device->can_swap_buffers())
+        gl_context.swap_buffers();
 }
 
 MirOrientation mga::DisplayBuffer::orientation() const

=== modified file 'src/platforms/android/server/display_component_factory.h'
--- src/platforms/android/server/display_component_factory.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/display_component_factory.h	2016-01-25 17:04:59 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_GRAPHICS_ANDROID_DISPLAY_COMPONENT_FACTORY_H_
 #define MIR_GRAPHICS_ANDROID_DISPLAY_COMPONENT_FACTORY_H_
 
+#include "mir/graphics/egl_sync_fence.h"
 #include "display_device.h"
 #include "framebuffer_bundle.h"
 #include <memory>
@@ -28,6 +29,7 @@
 namespace graphics
 {
 class DisplayConfigurationOutput;
+class CommandStreamSync;
 namespace android
 {
 class HwcConfiguration;

=== modified file 'src/platforms/android/server/display_device.h'
--- src/platforms/android/server/display_device.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/display_device.h	2016-01-25 17:04:59 +0000
@@ -69,6 +69,8 @@
 
     virtual std::chrono::milliseconds recommended_sleep() const = 0;
 
+    virtual bool can_swap_buffers() const = 0;
+
 protected:
     DisplayDevice() = default;
     DisplayDevice& operator=(DisplayDevice const&) = delete;

=== added file 'src/platforms/android/server/egl_sync_factory.cpp'
--- src/platforms/android/server/egl_sync_factory.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/android/server/egl_sync_factory.cpp	2016-01-25 17:04:59 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "cmdstream_sync_factory.h"
+#include "mir/graphics/egl_sync_fence.h"
+namespace mg = mir::graphics;
+namespace mga = mir::graphics::android;
+
+std::unique_ptr<mg::CommandStreamSync> mga::EGLSyncFactory::create_command_stream_sync()
+{
+    try
+    {
+        return std::make_unique<EGLSyncFence>(std::make_shared<mg::EGLSyncExtensions>());
+    }
+    catch (std::runtime_error&)
+    {
+        return std::make_unique<NullCommandSync>();
+    }
+}

=== modified file 'src/platforms/android/server/fb_device.cpp'
--- src/platforms/android/server/fb_device.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/fb_device.cpp	2016-01-25 17:04:59 +0000
@@ -99,8 +99,6 @@
     });
     if (primary_contents == contents.end()) return;
     auto& context = primary_contents->context;
-    
-    context.swap_buffers();
     auto const& buffer = context.last_rendered_buffer();
     auto native_buffer = buffer->native_buffer_handle();
     native_buffer->ensure_available_for(mga::BufferAccess::read);
@@ -123,3 +121,8 @@
 {
     return std::chrono::milliseconds::zero();
 }
+
+bool mga::FBDevice::can_swap_buffers() const
+{
+    return true;
+}

=== modified file 'src/platforms/android/server/fb_device.h'
--- src/platforms/android/server/fb_device.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/fb_device.h	2016-01-25 17:04:59 +0000
@@ -52,6 +52,7 @@
     bool compatible_renderlist(RenderableList const& renderlist) override;
     void commit(std::list<DisplayContents> const& contents) override;
     std::chrono::milliseconds recommended_sleep() const override;
+    bool can_swap_buffers() const override;
 
 private:
     std::shared_ptr<framebuffer_device_t> const fb_device;

=== modified file 'src/platforms/android/server/hal_component_factory.cpp'
--- src/platforms/android/server/hal_component_factory.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/hal_component_factory.cpp	2016-01-25 17:04:59 +0000
@@ -46,7 +46,8 @@
       res_factory(res_factory),
       hwc_report(hwc_report),
       force_backup_display(false),
-      num_framebuffers{quirks->num_framebuffers()}
+      num_framebuffers{quirks->num_framebuffers()},
+      working_egl_sync(quirks->working_egl_sync())
 {
     try
     {
@@ -65,6 +66,24 @@
     }
 }
 
+std::unique_ptr<mg::CommandStreamSync> mga::HalComponentFactory::create_command_stream_sync()
+{
+    if (hwc_version == mga::HwcVersion::hwc10)
+        return std::make_unique<NullCommandSync>();
+
+    if (!working_egl_sync)
+        return std::make_unique<NullCommandSync>();
+
+    try
+    {
+        return std::make_unique<EGLSyncFence>(std::make_shared<mg::EGLSyncExtensions>());
+    }
+    catch (std::runtime_error&)
+    {
+        return std::make_unique<NullCommandSync>();
+    }
+}
+
 std::unique_ptr<mga::FramebufferBundle> mga::HalComponentFactory::create_framebuffers(mg::DisplayConfigurationOutput const& config)
 {
     return std::unique_ptr<mga::FramebufferBundle>(new mga::Framebuffers(

=== modified file 'src/platforms/android/server/hal_component_factory.h'
--- src/platforms/android/server/hal_component_factory.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/hal_component_factory.h	2016-01-25 17:04:59 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_GRAPHICS_ANDROID_HAL_COMPONENT_FACTORY_H_
 #define MIR_GRAPHICS_ANDROID_HAL_COMPONENT_FACTORY_H_
 
+#include "cmdstream_sync_factory.h"
 #include "display_component_factory.h"
 #include "display_resource_factory.h"
 
@@ -39,7 +40,7 @@
 
 //NOTE: this should be the only class that inspects the HWC version and assembles
 //the components accordingly
-class HalComponentFactory : public DisplayComponentFactory
+class HalComponentFactory : public DisplayComponentFactory, public CommandStreamSyncFactory
 {
 public:
     HalComponentFactory(
@@ -48,6 +49,7 @@
         std::shared_ptr<HwcReport> const& hwc_report,
         std::shared_ptr<DeviceQuirks> const& quirks);
 
+    std::unique_ptr<CommandStreamSync> create_command_stream_sync() override;
     std::unique_ptr<FramebufferBundle> create_framebuffers(DisplayConfigurationOutput const&) override;
     std::unique_ptr<DisplayDevice> create_display_device() override;
     std::unique_ptr<HwcConfiguration> create_hwc_configuration() override;
@@ -61,6 +63,7 @@
     std::shared_ptr<FramebufferBundle> framebuffers;
     bool force_backup_display;
     size_t num_framebuffers;
+    bool working_egl_sync;
 
     std::shared_ptr<HwcWrapper> hwc_wrapper;
     std::shared_ptr<framebuffer_device_t> fb_native;

=== modified file 'src/platforms/android/server/hwc_device.cpp'
--- src/platforms/android/server/hwc_device.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/hwc_device.cpp	2016-01-25 17:04:59 +0000
@@ -106,13 +106,13 @@
         if (content.list.needs_swapbuffers())
         {
             auto rejected_renderables = content.list.rejected_renderables();
-            auto current_context = mir::raii::paired_calls(
-                [&]{ content.context.make_current(); },
-                [&]{ content.context.release_current(); });
-            if (rejected_renderables.empty())
-                content.context.swap_buffers();
-            else
+            if (!rejected_renderables.empty())
+            {
+                auto current_context = mir::raii::paired_calls(
+                    [&]{ content.context.make_current(); },
+                    [&]{ content.context.release_current(); });
                 content.compositor.render(std::move(rejected_renderables), content.list_offset, content.context);
+            }
             content.list.setup_fb(content.context.last_rendered_buffer());
             content.list.swap_occurred();
             purely_overlays = false;
@@ -161,3 +161,8 @@
 {
     onscreen_overlay_buffers.clear();
 }
+
+bool mga::HwcDevice::can_swap_buffers() const
+{
+    return true;
+}

=== modified file 'src/platforms/android/server/hwc_device.h'
--- src/platforms/android/server/hwc_device.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/hwc_device.h	2016-01-25 17:04:59 +0000
@@ -47,6 +47,7 @@
     void commit(std::list<DisplayContents> const& contents) override;
     void content_cleared() override;
     std::chrono::milliseconds recommended_sleep() const override;
+    bool can_swap_buffers() const override;
 
 private:
     bool buffer_is_onscreen(Buffer const&) const;

=== modified file 'src/platforms/android/server/hwc_fb_device.cpp'
--- src/platforms/android/server/hwc_fb_device.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/hwc_fb_device.cpp	2016-01-25 17:04:59 +0000
@@ -118,3 +118,8 @@
 {
     return std::chrono::milliseconds::zero();
 }
+
+bool mga::HwcFbDevice::can_swap_buffers() const
+{
+    return false;
+}

=== modified file 'src/platforms/android/server/hwc_fb_device.h'
--- src/platforms/android/server/hwc_fb_device.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/hwc_fb_device.h	2016-01-25 17:04:59 +0000
@@ -44,6 +44,7 @@
     bool compatible_renderlist(RenderableList const& renderlist) override;
     void commit(std::list<DisplayContents> const& contents) override;
     std::chrono::milliseconds recommended_sleep() const override;
+    bool can_swap_buffers() const override;
 
 private:
     void content_cleared() override;

=== modified file 'src/platforms/android/server/ipc_operations.cpp'
--- src/platforms/android/server/ipc_operations.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/ipc_operations.cpp	2016-01-25 17:04:59 +0000
@@ -32,6 +32,7 @@
 {
     auto native_buffer = buffer.native_buffer_handle();
 
+    native_buffer->wait_for_unlock_by_gpu();
     mir::Fd fence_fd(native_buffer->copy_fence());
     if (fence_fd != mir::Fd::invalid)
     {

=== modified file 'src/platforms/android/server/platform.cpp'
--- src/platforms/android/server/platform.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/platform.cpp	2016-01-25 17:04:59 +0000
@@ -85,11 +85,13 @@
 mga::Platform::Platform(
     std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
     std::shared_ptr<mga::DisplayComponentFactory> const& display_buffer_builder,
+    std::shared_ptr<CommandStreamSyncFactory> const& sync_factory,
     std::shared_ptr<mg::DisplayReport> const& display_report,
     mga::OverlayOptimization overlay_option,
     std::shared_ptr<mga::DeviceQuirks> const& quirks) :
     buffer_allocator(buffer_allocator),
     display_buffer_builder(display_buffer_builder),
+    sync_factory(sync_factory),
     display_report(display_report),
     quirks(quirks),
     overlay_option(overlay_option)
@@ -153,10 +155,13 @@
     auto overlay_option = should_use_overlay_optimization(*options);
     hwc_report->report_overlay_optimization(overlay_option);
     auto display_resource_factory = std::make_shared<mga::ResourceFactory>();
-    auto buffer_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(quirks);
+    auto sync_factory = std::make_shared<mga::EGLSyncFactory>();
+    auto buffer_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(sync_factory, quirks);
     auto component_factory = std::make_shared<mga::HalComponentFactory>(
         buffer_allocator, display_resource_factory, hwc_report, quirks);
-    return mir::make_module_ptr<mga::Platform>(buffer_allocator, component_factory, display_report, overlay_option, quirks);
+
+    return mir::make_module_ptr<mga::Platform>(
+        buffer_allocator, component_factory, component_factory, display_report, overlay_option, quirks);
 }
 
 mir::UniqueModulePtr<mg::Platform> create_guest_platform(
@@ -166,10 +171,11 @@
     mir::assert_entry_point_signature<mg::CreateGuestPlatform>(&create_guest_platform);
     //TODO: actually allow disabling quirks for guest platform
     auto quirks = std::make_shared<mga::DeviceQuirks>(mga::PropertiesOps{});
+    auto sync_factory = std::make_shared<mga::EGLSyncFactory>();
     //TODO: remove nullptr parameter once platform classes are sorted.
     //      mg::NativePlatform cannot create a display anyways, so it doesnt need a  display builder
-    auto const buffer_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(quirks);
-    return mir::make_module_ptr<mga::Platform>(buffer_allocator, nullptr, display_report, mga::OverlayOptimization::disabled, quirks);
+    auto const buffer_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(sync_factory, quirks);
+    return mir::make_module_ptr<mga::Platform>(buffer_allocator, nullptr, sync_factory, display_report, mga::OverlayOptimization::disabled, quirks);
 }
 
 void add_graphics_platform_options(

=== modified file 'src/platforms/android/server/platform.h'
--- src/platforms/android/server/platform.h	2015-12-11 12:22:15 +0000
+++ src/platforms/android/server/platform.h	2016-01-25 17:04:59 +0000
@@ -33,6 +33,7 @@
 class GraphicBufferAllocator;
 class FramebufferFactory;
 class DisplayComponentFactory;
+class CommandStreamSyncFactory;
 
 class Platform : public graphics::Platform
 {
@@ -40,6 +41,7 @@
     Platform(
         std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
         std::shared_ptr<DisplayComponentFactory> const& display_buffer_builder,
+        std::shared_ptr<CommandStreamSyncFactory> const& sync_factory,
         std::shared_ptr<DisplayReport> const& display_report,
         OverlayOptimization overlay_option,
         std::shared_ptr<DeviceQuirks> const& quirks);
@@ -55,6 +57,7 @@
 private:
     std::shared_ptr<graphics::GraphicBufferAllocator> const buffer_allocator;
     std::shared_ptr<DisplayComponentFactory> const display_buffer_builder;
+    std::shared_ptr<CommandStreamSyncFactory> const sync_factory;
     std::shared_ptr<DisplayReport> const display_report;
     std::shared_ptr<PlatformIpcOperations> const ipc_operations;
     std::shared_ptr<DeviceQuirks> const quirks;

=== modified file 'src/platforms/mesa/server/common/gbm_buffer.cpp'
--- src/platforms/mesa/server/common/gbm_buffer.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/mesa/server/common/gbm_buffer.cpp	2016-01-25 17:04:59 +0000
@@ -197,3 +197,12 @@
 {
     return this;
 }
+
+void mgm::GBMBuffer::secure_for_render()
+{
+}
+
+void mgm::GBMBuffer::bind()
+{
+    gl_bind_to_texture();
+}

=== modified file 'src/platforms/mesa/server/common/gbm_buffer.h'
--- src/platforms/mesa/server/common/gbm_buffer.h	2015-12-11 12:22:15 +0000
+++ src/platforms/mesa/server/common/gbm_buffer.h	2016-01-25 17:04:59 +0000
@@ -67,6 +67,8 @@
     virtual std::shared_ptr<MirNativeBuffer> native_buffer_handle() const override;
 
     virtual void gl_bind_to_texture() override;
+    virtual void bind() override;
+    virtual void secure_for_render() override;
 
     void write(unsigned char const* pixels, size_t size) override;
     void read(std::function<void(unsigned char const*)> const& do_with_pixels) override;

=== modified file 'src/platforms/mesa/server/common/shm_buffer.cpp'
--- src/platforms/mesa/server/common/shm_buffer.cpp	2015-12-11 12:22:15 +0000
+++ src/platforms/mesa/server/common/shm_buffer.cpp	2016-01-25 17:04:59 +0000
@@ -176,3 +176,12 @@
 {
     return this;
 }
+
+void mgm::ShmBuffer::bind()
+{
+    gl_bind_to_texture();
+}
+
+void mgm::ShmBuffer::secure_for_render()
+{
+}

=== modified file 'src/platforms/mesa/server/common/shm_buffer.h'
--- src/platforms/mesa/server/common/shm_buffer.h	2015-12-11 12:22:15 +0000
+++ src/platforms/mesa/server/common/shm_buffer.h	2016-01-25 17:04:59 +0000
@@ -51,6 +51,8 @@
     MirPixelFormat pixel_format() const override;
     std::shared_ptr<MirNativeBuffer> native_buffer_handle() const override;
     void gl_bind_to_texture() override;
+    void bind() override;
+    void secure_for_render() override;
     void write(unsigned char const* data, size_t size) override;
     void read(std::function<void(unsigned char const*)> const& do_with_pixels) override;
     NativeBufferBase* native_buffer_base() override;

=== modified file 'tests/include/mir/test/doubles/mock_android_native_buffer.h'
--- tests/include/mir/test/doubles/mock_android_native_buffer.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/mock_android_native_buffer.h	2016-01-25 17:04:59 +0000
@@ -57,6 +57,8 @@
     MOCK_METHOD1(ensure_available_for, void(graphics::android::BufferAccess));
     MOCK_METHOD2(update_usage, void(graphics::android::NativeFence&, graphics::android::BufferAccess));
 
+    MOCK_METHOD0(lock_for_gpu, void());
+    MOCK_METHOD0(wait_for_unlock_by_gpu, void());
     ANativeWindowBuffer stub_anwb;
     native_handle_t native_handle;
 };

=== modified file 'tests/include/mir/test/doubles/mock_buffer.h'
--- tests/include/mir/test/doubles/mock_buffer.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/mock_buffer.h	2016-01-25 17:04:59 +0000
@@ -72,6 +72,7 @@
     MOCK_METHOD2(write, void(unsigned char const*, size_t));
     MOCK_METHOD1(read, void(std::function<void(unsigned char const*)> const&));
     MOCK_METHOD0(native_buffer_base, graphics::NativeBufferBase*());
+    MOCK_METHOD0(used_as_texture, void());
 };
 
 }

=== modified file 'tests/include/mir/test/doubles/mock_display_device.h'
--- tests/include/mir/test/doubles/mock_display_device.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/mock_display_device.h	2016-01-25 17:04:59 +0000
@@ -39,6 +39,8 @@
     {
         ON_CALL(*this, compatible_renderlist(testing::_))
             .WillByDefault(testing::Return(true));
+        ON_CALL(*this, can_swap_buffers())
+            .WillByDefault(testing::Return(true));
     }
     ~MockDisplayDevice() noexcept {}
     MOCK_METHOD0(content_cleared, void());
@@ -46,6 +48,7 @@
     MOCK_METHOD1(compatible_renderlist, bool(
         graphics::RenderableList const&));
     MOCK_CONST_METHOD0(recommended_sleep, std::chrono::milliseconds());
+    MOCK_CONST_METHOD0(can_swap_buffers, bool());
 };
 }
 }

=== modified file 'tests/include/mir/test/doubles/mock_gl_buffer.h'
--- tests/include/mir/test/doubles/mock_gl_buffer.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/mock_gl_buffer.h	2016-01-25 17:04:59 +0000
@@ -36,6 +36,8 @@
     using MockBuffer::MockBuffer;
 
     MOCK_METHOD0(gl_bind_to_texture, void());
+    MOCK_METHOD0(secure_for_render, void());
+    MOCK_METHOD0(bind, void());
 };
 
 }

=== modified file 'tests/include/mir/test/doubles/stub_android_native_buffer.h'
--- tests/include/mir/test/doubles/stub_android_native_buffer.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/stub_android_native_buffer.h	2016-01-25 17:04:59 +0000
@@ -47,6 +47,9 @@
     void ensure_available_for(graphics::android::BufferAccess) {}
     void update_usage(graphics::android::NativeFence&, graphics::android::BufferAccess) {}
 
+    void lock_for_gpu() {};
+    void wait_for_unlock_by_gpu() {};
+
     ANativeWindowBuffer stub_anwb;
     native_handle_t native_handle;
 };

=== added file 'tests/include/mir/test/doubles/stub_cmdstream_sync_factory.h'
--- tests/include/mir/test/doubles/stub_cmdstream_sync_factory.h	1970-01-01 00:00:00 +0000
+++ tests/include/mir/test/doubles/stub_cmdstream_sync_factory.h	2016-01-25 17:04:59 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_CMDSTREAM_SYNC_FACTORY_H_
+#define MIR_TEST_DOUBLES_STUB_CMDSTREAM_SYNC_FACTORY_H_
+
+#include "src/platforms/android/server/cmdstream_sync_factory.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+struct StubCmdStreamSyncFactory : graphics::android::CommandStreamSyncFactory
+{
+    std::unique_ptr<graphics::CommandStreamSync> create_command_stream_sync() override
+    {
+        return std::make_unique<graphics::NullCommandSync>();
+    }
+};
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_STUB_CMDSTREAM_SYNC_FACTORY_H_ */

=== modified file 'tests/include/mir/test/doubles/stub_display_builder.h'
--- tests/include/mir/test/doubles/stub_display_builder.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/stub_display_builder.h	2016-01-25 17:04:59 +0000
@@ -126,6 +126,11 @@
         config = std::move(mock_config); 
     }
 
+    std::unique_ptr<graphics::CommandStreamSync> create_command_stream_sync()
+    {
+        return std::make_unique<graphics::NullCommandSync>();
+    }
+
     geometry::Size sz;
     std::unique_ptr<graphics::android::HwcConfiguration> config;
 };

=== modified file 'tests/include/mir/test/doubles/stub_gl_buffer.h'
--- tests/include/mir/test/doubles/stub_gl_buffer.h	2015-12-11 12:22:15 +0000
+++ tests/include/mir/test/doubles/stub_gl_buffer.h	2016-01-25 17:04:59 +0000
@@ -36,6 +36,8 @@
     using StubBuffer::StubBuffer;
 
     void gl_bind_to_texture() {}
+    void bind() {}
+    void secure_for_render() {}
 };
 
 }

=== modified file 'tests/integration-tests/graphics/mesa/test_buffer_integration.cpp'
--- tests/integration-tests/graphics/mesa/test_buffer_integration.cpp	2015-12-11 12:22:15 +0000
+++ tests/integration-tests/graphics/mesa/test_buffer_integration.cpp	2016-01-25 17:04:59 +0000
@@ -77,6 +77,9 @@
         }
     }
 
+    void bind() override { gl_bind_to_texture(); }
+    void secure_for_render() override {}
+
 private:
     std::thread::id creation_thread_id;
 };

=== modified file 'tests/unit-tests/gl/test_gl_texture_cache.cpp'
--- tests/unit-tests/gl/test_gl_texture_cache.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/gl/test_gl_texture_cache.cpp	2016-01-25 17:04:59 +0000
@@ -17,7 +17,7 @@
  * Originally by: Daniel van Vugt <[e-mail]>
  */
 
-#include "mir/gl/recently_used_cache.h"
+#include "src/gl/recently_used_cache.h"
 #include "mir/test/doubles/mock_gl_buffer.h"
 #include "mir/test/doubles/mock_renderable.h"
 #include "mir/test/doubles/mock_gl.h"
@@ -75,6 +75,7 @@
     EXPECT_CALL(mock_gl, glBindTexture(GL_TEXTURE_2D, stub_texture));
     EXPECT_CALL(*mock_buffer,gl_bind_to_texture())
         .Times(0);
+    EXPECT_CALL(*mock_buffer, used_as_texture());
 
     // Frame 3: Texture found in cache but refreshed with new buffer
     EXPECT_CALL(*mock_buffer, id())
@@ -92,6 +93,7 @@
     EXPECT_CALL(*mock_buffer, id())
         .WillOnce(Return(mg::BufferID(456)));
     EXPECT_CALL(mock_gl, glBindTexture(GL_TEXTURE_2D, stub_texture));
+    EXPECT_CALL(*mock_buffer, used_as_texture());
 
     EXPECT_CALL(mock_gl, glDeleteTextures(1, Pointee(stub_texture)));
 

=== modified file 'tests/unit-tests/gl/test_program_factory.cpp'
--- tests/unit-tests/gl/test_program_factory.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/gl/test_program_factory.cpp	2016-01-25 17:04:59 +0000
@@ -24,7 +24,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <mir/geometry/rectangle.h>
-#include "src/gl/default_program_factory.h"
+#include "mir/gl/default_program_factory.h"
 #include <mir/test/fake_shared.h>
 #include <mir/test/doubles/mock_buffer.h>
 #include <mir/test/doubles/mock_renderable.h>

=== modified file 'tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp'
--- tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2016-01-25 17:04:59 +0000
@@ -17,11 +17,13 @@
  */
 
 #include "src/platforms/android/server/android_alloc_adaptor.h"
+#include "src/platforms/android/server/cmdstream_sync_factory.h"
 #include "src/platforms/android/server/device_quirks.h"
 #include "mir/graphics/android/native_buffer.h"
 
 #include "mir/test/doubles/mock_android_alloc_device.h"
 #include "mir/test/doubles/mock_alloc_adaptor.h"
+#include "mir/test/doubles/mock_egl.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -32,7 +34,6 @@
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
 
-
 class AdaptorICSTest : public ::testing::Test
 {
 public:
@@ -48,13 +49,15 @@
         mock_alloc_device = std::make_shared<NiceMock<mtd::MockAllocDevice>>();
 
         auto quirks = std::make_shared<mga::DeviceQuirks>(mga::PropertiesOps{});
-        alloc_adaptor = std::make_shared<mga::AndroidAllocAdaptor>(mock_alloc_device, quirks);
+        alloc_adaptor = std::make_shared<mga::AndroidAllocAdaptor>(mock_alloc_device, sync_factory, quirks);
 
         pf = mir_pixel_format_abgr_8888;
         size = geom::Size{300, 200};
         usage = mga::BufferUsage::use_hardware;
     }
 
+    mtd::MockEGL mock_egl;
+    std::shared_ptr<mga::CommandStreamSyncFactory> sync_factory{std::make_shared<mga::EGLSyncFactory>()};
     std::shared_ptr<mtd::MockAllocDevice> mock_alloc_device;
     std::shared_ptr<mga::AndroidAllocAdaptor> alloc_adaptor;
 

=== modified file 'tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp'
--- tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_android_buffer_allocator.cpp	2016-01-25 17:04:59 +0000
@@ -23,6 +23,8 @@
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/android/native_buffer.h"
 
+#include "mir/test/doubles/stub_display_builder.h"
+#include "mir/test/doubles/stub_cmdstream_sync_factory.h"
 #include "mir/test/doubles/mock_egl.h"
 
 #include <hardware/gralloc.h>
@@ -43,7 +45,9 @@
 
     testing::NiceMock<mtd::HardwareAccessMock> hw_access_mock;
     testing::NiceMock<mtd::MockEGL> mock_egl;
-    mga::AndroidGraphicBufferAllocator allocator{std::make_shared<mga::DeviceQuirks>(mga::PropertiesOps{})};
+    mga::AndroidGraphicBufferAllocator allocator{
+        std::make_shared<mtd::StubCmdStreamSyncFactory>(),
+        std::make_shared<mga::DeviceQuirks>(mga::PropertiesOps{})};
 };
 
 TEST_F(AndroidGraphicBufferAllocatorTest, allocator_accesses_gralloc_module)
@@ -54,7 +58,7 @@
         .Times(1);
 
     auto quirks = std::make_shared<mga::DeviceQuirks>(mga::PropertiesOps{});
-    mga::AndroidGraphicBufferAllocator allocator{quirks};
+    mga::AndroidGraphicBufferAllocator allocator{std::make_shared<mtd::StubCmdStreamSyncFactory>(), quirks};
 }
 
 TEST_F(AndroidGraphicBufferAllocatorTest, supported_pixel_formats_contain_common_formats)

=== modified file 'tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp'
--- tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_buffer_tex_bind.cpp	2016-01-25 17:04:59 +0000
@@ -289,7 +289,7 @@
 
 
 /* binding tests */
-TEST_F(AndroidBufferBinding, buffer_calls_binding_extension)
+TEST_F(AndroidBufferBinding, buffer_calls_binding_extension_and_notes_gpu_usage)
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
@@ -298,11 +298,23 @@
     buffer.gl_bind_to_texture();
 }
 
+TEST_F(AndroidBufferBinding, notes_gpu_usage_when_explicity_told)
+{
+    using namespace testing;
+    EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
+        .Times(0);
+    EXPECT_CALL(*mock_native_buffer, lock_for_gpu()); 
+    mga::Buffer buffer(gralloc, mock_native_buffer, extensions);
+    buffer.secure_for_render();
+}
+
 TEST_F(AndroidBufferBinding, buffer_calls_binding_extension_every_time)
 {
     using namespace testing;
     EXPECT_CALL(mock_egl, glEGLImageTargetTexture2DOES(_, _))
         .Times(Exactly(3));
+    EXPECT_CALL(*mock_native_buffer, lock_for_gpu())
+        .Times(Exactly(3));
 
     mga::Buffer buffer(gralloc, mock_native_buffer, extensions);
     buffer.gl_bind_to_texture();

=== modified file 'tests/unit-tests/graphics/android/test_display_buffer.cpp'
--- tests/unit-tests/graphics/android/test_display_buffer.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_display_buffer.cpp	2016-01-25 17:04:59 +0000
@@ -235,6 +235,21 @@
     db.release_current();
 }
 
+//In HWC 1.0 notably we cannot eglSwapBuffers on the fb context.
+TEST_F(DisplayBuffer, swaps_when_allowed)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_display_device, can_swap_buffers())
+        .Times(2)
+        .WillOnce(Return(true))
+        .WillOnce(Return(false));
+    EXPECT_CALL(mock_egl, eglSwapBuffers(dummy_display, mock_egl.fake_egl_surface))
+        .Times(1);
+
+    db.swap_buffers();
+    db.swap_buffers();
+}
+
 TEST_F(DisplayBuffer, notifies_list_that_content_is_cleared)
 {
     EXPECT_CALL(*mock_display_device, content_cleared())

=== modified file 'tests/unit-tests/graphics/android/test_display_hotplug.cpp'
--- tests/unit-tests/graphics/android/test_display_hotplug.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_display_hotplug.cpp	2016-01-25 17:04:59 +0000
@@ -103,6 +103,11 @@
                 new mga::LayerList(std::make_shared<mga::IntegerSourceCrop>(), {}, geom::Displacement{}));
         }
 
+        std::unique_ptr<mg::CommandStreamSync> create_command_stream_sync()
+        {
+            return nullptr;
+        }
+
         StubHwcConfig stub_config;
     };
 

=== modified file 'tests/unit-tests/graphics/android/test_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_fb_device.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_fb_device.cpp	2016-01-25 17:04:59 +0000
@@ -72,6 +72,12 @@
     mga::DisplayName primary{mga::DisplayName::primary};
 };
 
+TEST_F(FBDevice, reports_it_can_swap)
+{
+    mga::FBDevice fbdev(fb_hal_mock);
+    EXPECT_TRUE(fbdev.can_swap_buffers());
+}
+
 TEST_F(FBDevice, rejects_renderables)
 {
     mg::RenderableList renderlist
@@ -92,6 +98,8 @@
         .WillOnce(Return(-1))
         .WillOnce(Return(0));
 
+    EXPECT_CALL(mock_context, swap_buffers())
+        .Times(0);
     mga::FBDevice fbdev(fb_hal_mock);
     mga::DisplayContents content{primary, list, geom::Displacement{}, mock_context, stub_compositor};
 

=== modified file 'tests/unit-tests/graphics/android/test_hwc_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_device.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_hwc_device.cpp	2016-01-25 17:04:59 +0000
@@ -120,6 +120,12 @@
 };
 }
 
+TEST_F(HwcDevice, reports_it_can_swap)
+{
+    mga::HwcDevice device(mock_device);
+    EXPECT_TRUE(device.can_swap_buffers());
+}
+
 TEST_F(HwcDevice, prepares_a_skip_and_target_layer_by_default)
 {
     using namespace testing;
@@ -174,7 +180,7 @@
     device.commit({content});
 }
 
-TEST_F(HwcDevice, swaps_buffers_directly_when_no_renderables)
+TEST_F(HwcDevice, does_not_swap_buffers_when_no_renderables)
 {
     using namespace testing;
     mtd::MockRenderableListCompositor mock_compositor;
@@ -184,7 +190,8 @@
 
     EXPECT_CALL(mock_compositor, render(_,_,_))
         .Times(0);
-    EXPECT_CALL(mock_context, swap_buffers());
+    EXPECT_CALL(mock_context, swap_buffers())
+        .Times(0);
 
     mga::LayerList list(layer_adapter, {}, geom::Displacement{});
     mga::DisplayContents content{primary, list, offset, mock_context, mock_compositor};
@@ -465,8 +472,6 @@
     NiceMock<mtd::MockSwappingGLContext> mock_context;
     ON_CALL(mock_context, last_rendered_buffer())
         .WillByDefault(Return(stub_fb_buffer));
-    EXPECT_CALL(mock_context, swap_buffers())
-        .Times(AtLeast(5));
 
     mga::LayerList list(layer_adapter, {}, geom::Displacement{});
     mtd::MockRenderableListCompositor mock_compositor;
@@ -844,10 +849,6 @@
 
     InSequence seq;
     EXPECT_CALL(*mock_device, prepare(MatchesLists(expected_list, expected_list)));
-    EXPECT_CALL(mock_context1, make_current());
-    EXPECT_CALL(mock_context1, release_current());
-    EXPECT_CALL(mock_context2, make_current());
-    EXPECT_CALL(mock_context2, release_current());
     EXPECT_CALL(*mock_device, set(MatchesLists(expected_list, expected_list)));
 
     mga::LayerList primary_list(layer_adapter, {}, geom::Displacement{});

=== modified file 'tests/unit-tests/graphics/android/test_hwc_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_fb_device.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_hwc_fb_device.cpp	2016-01-25 17:04:59 +0000
@@ -104,6 +104,12 @@
 };
 }
 
+TEST_F(HwcFbDevice, reports_it_cannot_swap)
+{
+    mga::HwcFbDevice device(mock_hwc_device_wrapper, mock_fb_device);
+    EXPECT_FALSE(device.can_swap_buffers());
+}
+
 TEST_F(HwcFbDevice, hwc10_subscribes_to_vsync_events)
 {
     using namespace testing;

=== modified file 'tests/unit-tests/graphics/android/test_native_buffer.cpp'
--- tests/unit-tests/graphics/android/test_native_buffer.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_native_buffer.cpp	2016-01-25 17:04:59 +0000
@@ -17,25 +17,41 @@
  */
 
 #include "mir/graphics/android/android_native_buffer.h"
+#include "mir/graphics/egl_sync_fence.h"
 #include "mir/test/doubles/mock_fence.h"
 #include <memory>
 #include <gtest/gtest.h>
 
 namespace mtd=mir::test::doubles;
 namespace mga=mir::graphics::android;
+using namespace testing;
+
+namespace
+{
+struct MockCommandStreamSync : public mir::graphics::CommandStreamSync
+{
+    MOCK_METHOD0(raise, void());
+    MOCK_METHOD0(reset, void());
+    MOCK_METHOD1(wait_for, bool(std::chrono::nanoseconds));
+};
+}
 
 struct NativeBuffer : public testing::Test
 {
     NativeBuffer() :
         a_native_window_buffer(std::make_shared<ANativeWindowBuffer>()),
         mock_fence(std::make_shared<testing::NiceMock<mtd::MockFence>>()),
-        fake_fd{48484}
+        fake_fd{48484},
+        timeout{std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(2))},
+        mock_cmdstream_sync{std::make_shared<MockCommandStreamSync>()}
     {
     }
 
     std::shared_ptr<ANativeWindowBuffer> a_native_window_buffer;
     std::shared_ptr<mtd::MockFence> mock_fence;
     int fake_fd;
+    std::chrono::nanoseconds timeout;
+    std::shared_ptr<MockCommandStreamSync> mock_cmdstream_sync;
 };
 
 TEST_F(NativeBuffer, extends_lifetime_when_driver_calls_external_refcount_hooks)
@@ -88,7 +104,7 @@
 {
     EXPECT_CALL(*mock_fence, wait())
         .Times(0);
-    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_fence, mga::BufferAccess::read);
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
     buffer.ensure_available_for(mga::BufferAccess::read);
 }
 
@@ -96,7 +112,7 @@
 {
     EXPECT_CALL(*mock_fence, wait())
         .Times(1);
-    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_fence, mga::BufferAccess::write);
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::write);
     buffer.ensure_available_for(mga::BufferAccess::read);
 }
 
@@ -104,7 +120,7 @@
 {
     EXPECT_CALL(*mock_fence, wait())
         .Times(1);
-    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_fence, mga::BufferAccess::read);
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
     buffer.ensure_available_for(mga::BufferAccess::write);
 }
 
@@ -112,7 +128,7 @@
 {
     EXPECT_CALL(*mock_fence, wait())
         .Times(1);
-    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_fence, mga::BufferAccess::write);
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::write);
     buffer.ensure_available_for(mga::BufferAccess::write);
 }
 
@@ -120,7 +136,7 @@
 {
     EXPECT_CALL(*mock_fence, merge_with(fake_fd))
         .Times(1);
-    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_fence, mga::BufferAccess::read);
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
     buffer.update_usage(fake_fd, mga::BufferAccess::write);
 }
 
@@ -129,7 +145,7 @@
     EXPECT_CALL(*mock_fence, wait())
         .Times(3);
 
-    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_fence, mga::BufferAccess::read);
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
     buffer.ensure_available_for(mga::BufferAccess::write);
     buffer.ensure_available_for(mga::BufferAccess::read);
 
@@ -137,3 +153,30 @@
     buffer.ensure_available_for(mga::BufferAccess::write);
     buffer.ensure_available_for(mga::BufferAccess::read);
 }
+
+TEST_F(NativeBuffer, raises_egl_fence)
+{
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
+
+    EXPECT_CALL(*mock_cmdstream_sync, raise());
+    buffer.lock_for_gpu();
+}
+
+TEST_F(NativeBuffer, clears_egl_fence_successfully)
+{
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
+    EXPECT_CALL(*mock_cmdstream_sync, wait_for(timeout))
+        .Times(1)
+        .WillOnce(Return(true));
+    buffer.wait_for_unlock_by_gpu();
+}
+
+//not really helpful to throw if the timeout fails
+TEST_F(NativeBuffer, ignores_clears_egl_fence_failure)
+{
+    mga::AndroidNativeBuffer buffer(a_native_window_buffer, mock_cmdstream_sync, mock_fence, mga::BufferAccess::read);
+    EXPECT_CALL(*mock_cmdstream_sync, wait_for(timeout))
+        .Times(1)
+        .WillOnce(Return(false));
+    buffer.wait_for_unlock_by_gpu();
+}

=== modified file 'tests/unit-tests/graphics/android/test_platform.cpp'
--- tests/unit-tests/graphics/android/test_platform.cpp	2015-12-11 12:22:15 +0000
+++ tests/unit-tests/graphics/android/test_platform.cpp	2016-01-25 17:04:59 +0000
@@ -26,6 +26,7 @@
 #include "mir/test/doubles/mock_display_report.h"
 #include "mir/test/doubles/mock_egl.h"
 #include "mir/test/doubles/stub_display_builder.h"
+#include "mir/test/doubles/stub_cmdstream_sync_factory.h"
 #include "mir/test/doubles/fd_matcher.h"
 #include "mir/test/fake_shared.h"
 #include "mir/test/doubles/mock_android_native_buffer.h"
@@ -54,6 +55,7 @@
         using namespace testing;
 
         stub_display_builder = std::make_shared<mtd::StubDisplayBuilder>();
+        stub_sync_factory = std::make_shared<mtd::StubCmdStreamSyncFactory>();
         stub_display_report = mr::null_display_report();
         stride = geom::Stride(300*4);
 
@@ -86,6 +88,7 @@
     std::shared_ptr<mtd::MockAndroidNativeBuffer> native_buffer;
     std::shared_ptr<mtd::StubBufferAllocator> stub_buffer_allocator;
     std::shared_ptr<mtd::StubDisplayBuilder> stub_display_builder;
+    std::shared_ptr<mtd::StubCmdStreamSyncFactory> stub_sync_factory;
     std::shared_ptr<mtd::MockBuffer> mock_buffer;
     std::shared_ptr<native_handle_t> native_buffer_handle;
     std::shared_ptr<mg::DisplayReport> stub_display_report;
@@ -99,10 +102,12 @@
 {
     using namespace ::testing;
     int fake_fence{333};
+    EXPECT_CALL(*native_buffer, wait_for_unlock_by_gpu());
     EXPECT_CALL(*native_buffer, copy_fence())
         .WillOnce(Return(fake_fence));
 
-    mga::Platform platform(stub_buffer_allocator, stub_display_builder, stub_display_report, mga::OverlayOptimization::enabled, quirks);
+    mga::Platform platform(stub_buffer_allocator, stub_display_builder,
+        stub_sync_factory, stub_display_report, mga::OverlayOptimization::enabled, quirks);
 
     mtd::MockBufferIpcMessage mock_ipc_msg;
     int offset = 0;
@@ -130,10 +135,12 @@
 TEST_F(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_full_ipc_without_fence)
 {
     using namespace ::testing;
+    EXPECT_CALL(*native_buffer, wait_for_unlock_by_gpu());
     EXPECT_CALL(*native_buffer, copy_fence())
         .WillOnce(Return(-1));
 
-    mga::Platform platform(stub_buffer_allocator, stub_display_builder, stub_display_report, mga::OverlayOptimization::enabled, quirks);
+    mga::Platform platform(stub_buffer_allocator, stub_display_builder,
+        stub_sync_factory, stub_display_report, mga::OverlayOptimization::enabled, quirks);
 
     mtd::MockBufferIpcMessage mock_ipc_msg;
     int offset = 0;
@@ -169,10 +176,12 @@
 TEST_F(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_nested)
 {
     using namespace ::testing;
+    EXPECT_CALL(*native_buffer, wait_for_unlock_by_gpu());
     EXPECT_CALL(*native_buffer, copy_fence())
         .WillOnce(Return(-1));
 
-    mga::Platform platform(stub_buffer_allocator, stub_display_builder, stub_display_report, mga::OverlayOptimization::enabled, quirks);
+    mga::Platform platform(stub_buffer_allocator, stub_display_builder,
+        stub_sync_factory, stub_display_report, mga::OverlayOptimization::enabled, quirks);
 
     mtd::MockBufferIpcMessage mock_ipc_msg;
     int offset = 0;
@@ -207,7 +216,8 @@
     using namespace ::testing;
 
     int fake_fence{33};
-    mga::Platform platform(stub_buffer_allocator, stub_display_builder, stub_display_report, mga::OverlayOptimization::enabled, quirks);
+    mga::Platform platform(stub_buffer_allocator, stub_display_builder,
+        stub_sync_factory, stub_display_report, mga::OverlayOptimization::enabled, quirks);
     auto ipc_ops = platform.make_ipc_operations();
 
     mtd::MockBufferIpcMessage mock_ipc_msg;
@@ -234,6 +244,7 @@
     mga::Platform platform(
         std::make_shared<mtd::StubBufferAllocator>(),
         std::make_shared<mtd::StubDisplayBuilder>(),
+        std::make_shared<mtd::StubCmdStreamSyncFactory>(),
         mr::null_display_report(),
         mga::OverlayOptimization::enabled,
         std::make_shared<mga::DeviceQuirks>(mga::PropertiesOps{}));