Merge lp:~vanvugt/mir/drop-frame-dropping-policy into lp:mir

[Daniel van Vugt]

Drop FrameDroppingPolicy

For a few reasons:
  * It is no longer possible to trigger at all with client-side vsync,
    because swaps now always return after 16ms (hence the 100ms timeout
    is never reached).
  * The original use case for it is deprecated: The music player app
    in Unity8. And even if it wasn't, it still would never trigger since
    all toolkits other than Xmir already use client-side vsync.
  * Only mir_buffer_stream_swap_buffers can possibly trigger it and
    that is either deprecated [1] or will stop triggering it once
    ported to client-side vsync at least.

[1] https://code.launchpad.net/~vanvugt/mir/deprecate-mir_buffer_stream_swap_buffers/+merge/323484

This branch has a weak prerequisite on either [1] landing, or it
getting ported to client-side vsync.

[Mir CI Bot (mir-ci-bot)]

PASSED: Continuous integration, rev:3959
https://mir-jenkins.ubuntu.com/job/mir-ci/3389/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/4588
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4716
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4705
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4705
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4620
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4620/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/4620
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4620/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4620
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4620/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=mesa,release=zesty/4620
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=mesa,release=zesty/4620/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/4620
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4620/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

yes this should no longer be needed.

review: Approve

=== removed file 'src/include/server/mir/compositor/frame_dropping_policy.h'
--- src/include/server/mir/compositor/frame_dropping_policy.h	2015-02-22 07:46:25 +0000
+++ src/include/server/mir/compositor/frame_dropping_policy.h	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Christopher James Halse Rogers <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_FRAME_DROPPING_POLICY_H_
-#define MIR_COMPOSITOR_FRAME_DROPPING_POLICY_H_
-
-#include <functional>
-
-namespace mir
-{
-namespace compositor
-{
-/**
- * \brief Policy to determine when to drop a frame from a client
- *
- * The FrameDroppingPolicy objects are constructed from a
- * \ref FrameDroppingPolicyFactory
- *
- * The frame dropping mechanism is provided as the
- * \a drop_frames argument of \ref FrameDroppingPolicyFactory::create_policy
- *
- * The policy may decide to drop a frame any time that there is an outstanding
- * swap - namely, when there have been more calls to \ref swap_now_blocking
- * than to \ref swap_unblocked
- */
-class FrameDroppingPolicy
-{
-public:
-    virtual ~FrameDroppingPolicy() = default;
-
-    FrameDroppingPolicy(FrameDroppingPolicy const&) = delete;
-    FrameDroppingPolicy& operator=(FrameDroppingPolicy const&) = delete;
-
-    /**
-     * \brief Notify that a swap is now blocking
-     */
-    virtual void swap_now_blocking() = 0;
-    /**
-     * \brief Notify that previous swap is no longer blocking
-     */
-    virtual void swap_unblocked() = 0;
-
-protected:
-    /**
-     * \note FrameDroppingPolicies should not be constructed directly;
-     *       use a \ref FrameDroppingPolicyFactory
-     */
-    FrameDroppingPolicy() = default;
-};
-
-}
-}
-
-#endif // MIR_COMPOSITOR_FRAME_DROPPING_POLICY_H_

=== removed file 'src/include/server/mir/compositor/frame_dropping_policy_factory.h'
--- src/include/server/mir/compositor/frame_dropping_policy_factory.h	2017-01-18 02:29:37 +0000
+++ src/include/server/mir/compositor/frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
-#define MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
-
-#include <memory>
-
-namespace mir
-{
-class LockableCallback;
-
-namespace compositor
-{
-class FrameDroppingPolicy;
-
-/**
- * \brief Creator of FrameDroppingPolicies
- *
- * The FrameDroppingPolicyFactory is how you go from a means of dropping frames -
- * the \a drop_frames parameter of \ref create_policy -
- * to a \ref FrameDroppingPolicy
- */
-class FrameDroppingPolicyFactory
-{
-public:
-    FrameDroppingPolicyFactory() = default;
-    virtual ~FrameDroppingPolicyFactory() = default;
-
-    FrameDroppingPolicyFactory(FrameDroppingPolicyFactory const&) = delete;
-    FrameDroppingPolicyFactory& operator=(FrameDroppingPolicyFactory const&) = delete;
-
-    /**
-     * \brief Create a FrameDroppingPolicy that will call \a drop_frame when it
-     *       decides to drop a frame
-     *
-     * A LockableCallback allows the user to preserve lock ordering
-     * in situations where FrameDroppingPolicy methods need to be called under
-     * external lock and the callback implementation needs to run code protected
-     * by the same lock. A FrameDroppingPolicy implementation may have internal
-     * locks of its own, which maybe acquired during callback dispatching;
-     * to preserve lock ordering LockableCallback::lock will be invoked during
-     * callback dispatch before any internal locks are acquired.
-     *
-     * \param drop_frame Function to call when a frame needs to be dropped
-     * \param lock       Function called within the callback dispatcher context
-     *                   before any internal locks are acquired.
-     * \param unlock     Function called within the callback dispatcher context
-     *                   after any internal locks are released.
-     */
-    virtual std::unique_ptr<FrameDroppingPolicy> create_policy(
-        std::unique_ptr<LockableCallback> drop_frame) const = 0;
-};
-
-}
-}
-
-#endif // MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_

=== modified file 'src/include/server/mir/default_server_configuration.h'
--- src/include/server/mir/default_server_configuration.h	2017-04-13 07:00:27 +0000
+++ src/include/server/mir/default_server_configuration.h	2017-05-02 09:09:50 +0000
@@ -54,7 +54,6 @@
 class DisplayBufferCompositorFactory;
 class Compositor;
 class CompositorReport;
-class FrameDroppingPolicyFactory;
 }
 namespace frontend
 {
@@ -240,7 +239,6 @@
      *  @{ */
     virtual std::shared_ptr<graphics::GraphicBufferAllocator> the_buffer_allocator();
     virtual std::shared_ptr<compositor::Scene>                  the_scene();
-    virtual std::shared_ptr<compositor::FrameDroppingPolicyFactory> the_frame_dropping_policy_factory();
     /** @} */
 
     /** @name frontend configuration - dependencies
@@ -409,7 +407,6 @@
     CachedPtr<frontend::InputConfigurationChanger> input_configuration_changer;
     CachedPtr<renderer::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
-    CachedPtr<compositor::FrameDroppingPolicyFactory> frame_dropping_policy_factory;
     CachedPtr<scene::SurfaceStack> scene_surface_stack;
     CachedPtr<shell::SurfaceStack> surface_stack;
     CachedPtr<scene::SceneReport> scene_report;

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2017-01-18 02:29:37 +0000
+++ src/server/compositor/CMakeLists.txt	2017-05-02 09:09:50 +0000
@@ -16,14 +16,11 @@
   default_configuration.cpp
   screencast_display_buffer.cpp
   compositing_screencast.cpp
-  timeout_frame_dropping_policy_factory.cpp
   stream.cpp
   multi_monitor_arbiter.cpp
   buffer_map.cpp
   dropping_schedule.cpp
   queueing_schedule.cpp
-  ${PROJECT_SOURCE_DIR}/src/include/server/mir/compositor/frame_dropping_policy.h
-  ${PROJECT_SOURCE_DIR}/src/include/server/mir/compositor/frame_dropping_policy_factory.h
 )
 
 ADD_LIBRARY(

=== modified file 'src/server/compositor/buffer_stream_factory.cpp'
--- src/server/compositor/buffer_stream_factory.cpp	2017-01-18 02:29:37 +0000
+++ src/server/compositor/buffer_stream_factory.cpp	2017-05-02 09:09:50 +0000
@@ -26,7 +26,6 @@
 #include "mir/graphics/buffer_id.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/graphics/display.h"
-#include "mir/compositor/frame_dropping_policy.h"
 
 #include <cassert>
 #include <memory>
@@ -36,11 +35,8 @@
 namespace ms = mir::scene;
 namespace mf = mir::frontend;
 
-mc::BufferStreamFactory::BufferStreamFactory(
-    std::shared_ptr<mc::FrameDroppingPolicyFactory> const& policy_factory) :
-    policy_factory{policy_factory}
+mc::BufferStreamFactory::BufferStreamFactory()
 {
-    assert(policy_factory);
 }
 
 std::shared_ptr<mc::BufferStream> mc::BufferStreamFactory::create_buffer_stream(
@@ -55,7 +51,6 @@
     int, mg::BufferProperties const& buffer_properties)
 {
     return std::make_shared<mc::Stream>(
-        *policy_factory,
         buffers,
         buffer_properties.size, buffer_properties.format);
 }

=== modified file 'src/server/compositor/buffer_stream_factory.h'
--- src/server/compositor/buffer_stream_factory.h	2017-01-18 02:29:37 +0000
+++ src/server/compositor/buffer_stream_factory.h	2017-05-02 09:09:50 +0000
@@ -22,7 +22,6 @@
 #define MIR_COMPOSITOR_BUFFER_STREAM_FACTORY_H_
 
 #include "mir/scene/buffer_stream_factory.h"
-#include "mir/compositor/frame_dropping_policy_factory.h"
 
 #include <memory>
 
@@ -38,7 +37,7 @@
 class BufferStreamFactory : public scene::BufferStreamFactory
 {
 public:
-    BufferStreamFactory(std::shared_ptr<FrameDroppingPolicyFactory> const& policy_factory);
+    BufferStreamFactory();
 
     virtual ~BufferStreamFactory() {}
 
@@ -50,9 +49,6 @@
         graphics::BufferProperties const&) override;
     virtual std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
         std::shared_ptr<frontend::BufferSink> const& sink) override;
-
-private:
-    std::shared_ptr<FrameDroppingPolicyFactory> const policy_factory;
 };
 
 }

=== modified file 'src/server/compositor/default_configuration.cpp'
--- src/server/compositor/default_configuration.cpp	2017-01-30 05:18:36 +0000
+++ src/server/compositor/default_configuration.cpp	2017-05-02 09:09:50 +0000
@@ -24,7 +24,6 @@
 #include "multi_threaded_compositor.h"
 #include "gl/renderer_factory.h"
 #include "compositing_screencast.h"
-#include "timeout_frame_dropping_policy_factory.h"
 #include "mir/main_loop.h"
 
 #include "mir/frontend/screencast.h"
@@ -42,19 +41,7 @@
     return buffer_stream_factory(
         [this]()
         {
-            return std::make_shared<mc::BufferStreamFactory>(
-                the_frame_dropping_policy_factory());
-        });
-}
-
-std::shared_ptr<mc::FrameDroppingPolicyFactory>
-mir::DefaultServerConfiguration::the_frame_dropping_policy_factory()
-{
-    return frame_dropping_policy_factory(
-        [this]()
-        {
-            return std::make_shared<mc::TimeoutFrameDroppingPolicyFactory>(the_main_loop(),
-                                                                           std::chrono::milliseconds{100});
+            return std::make_shared<mc::BufferStreamFactory>();
         });
 }
 

=== modified file 'src/server/compositor/stream.cpp'
--- src/server/compositor/stream.cpp	2017-03-14 02:26:28 +0000
+++ src/server/compositor/stream.cpp	2017-05-02 09:09:50 +0000
@@ -23,8 +23,6 @@
 #include "temporary_buffers.h"
 #include "mir/frontend/client_buffers.h"
 #include "mir/graphics/buffer.h"
-#include "mir/compositor/frame_dropping_policy_factory.h"
-#include "mir/compositor/frame_dropping_policy.h"
 #include <boost/throw_exception.hpp>
 
 namespace mc = mir::compositor;
@@ -38,31 +36,8 @@
     Dropping
 };
 
-mc::Stream::DroppingCallback::DroppingCallback(Stream* stream) :
-    stream(stream)
-{
-}
-
-void mc::Stream::DroppingCallback::operator()()
-{
-    stream->drop_frame();
-}
-
-void mc::Stream::DroppingCallback::lock()
-{
-    guard_lock = std::unique_lock<std::mutex>{stream->mutex};
-}
-
-void mc::Stream::DroppingCallback::unlock()
-{
-    if (guard_lock.owns_lock())
-        guard_lock.unlock();
-}
-
 mc::Stream::Stream(
-    mc::FrameDroppingPolicyFactory const& policy_factory,
     std::shared_ptr<frontend::ClientBuffers> map, geom::Size size, MirPixelFormat pf) :
-    drop_policy(policy_factory.create_policy(std::make_unique<DroppingCallback>(this))),
     schedule_mode(ScheduleMode::Queueing),
     schedule(std::make_shared<mc::QueueingSchedule>()),
     buffers(map),
@@ -100,8 +75,6 @@
         first_frame_posted = true;
         buffers->receive_buffer(buffer->id());
         deferred_io = schedule->schedule_nonblocking(buffers->get(buffer->id()));
-        if (!associated_buffers.empty() && (client_owned_buffer_count(lk) == 0))
-            drop_policy->swap_now_blocking();
     }
     observers.frame_posted(1, buffer->size());
 
@@ -139,10 +112,6 @@
 
 std::shared_ptr<mg::Buffer> mc::Stream::lock_compositor_buffer(void const* id)
 {
-    {
-        std::lock_guard<decltype(mutex)> lk(mutex);
-        drop_policy->swap_unblocked();
-    }
     return std::make_shared<mc::TemporaryCompositorBuffer>(arbiter, id);
 }
 
@@ -242,12 +211,6 @@
 {
 }
 
-void mc::Stream::drop_frame()
-{
-    if (schedule->num_scheduled() > 1)
-        buffers->send_buffer(schedule->next_buffer()->id());
-}
-
 bool mc::Stream::suitable_for_cursor() const
 {
     if (associated_buffers.empty())

=== modified file 'src/server/compositor/stream.h'
--- src/server/compositor/stream.h	2017-03-14 02:26:28 +0000
+++ src/server/compositor/stream.h	2017-05-02 09:09:50 +0000
@@ -36,14 +36,10 @@
 namespace compositor
 {
 class Schedule;
-class FrameDroppingPolicyFactory;
-class FrameDroppingPolicy;
 class Stream : public BufferStream
 {
 public:
-    Stream(
-        FrameDroppingPolicyFactory const& policy_factory,
-        std::shared_ptr<frontend::ClientBuffers>, geometry::Size sz, MirPixelFormat format);
+    Stream(std::shared_ptr<frontend::ClientBuffers>, geometry::Size sz, MirPixelFormat format);
     ~Stream();
 
     void submit_buffer(std::shared_ptr<graphics::Buffer> const& buffer) override;
@@ -67,20 +63,9 @@
 
 private:
     enum class ScheduleMode;
-    struct DroppingCallback : mir::LockableCallback
-    {
-        DroppingCallback(Stream* stream);
-        void operator()() override;
-        void lock() override;
-        void unlock() override;
-        Stream* stream;
-        std::unique_lock<std::mutex> guard_lock;
-    };
     void transition_schedule(std::shared_ptr<Schedule>&& new_schedule, std::lock_guard<std::mutex> const&);
-    void drop_frame();
 
     std::mutex mutable mutex;
-    std::unique_ptr<compositor::FrameDroppingPolicy> drop_policy;
     ScheduleMode schedule_mode;
     std::shared_ptr<Schedule> schedule;
     std::shared_ptr<frontend::ClientBuffers> const buffers;

=== removed file 'src/server/compositor/timeout_frame_dropping_policy_factory.cpp'
--- src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2017-03-14 02:26:28 +0000
+++ src/server/compositor/timeout_frame_dropping_policy_factory.cpp	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-#include "mir/compositor/frame_dropping_policy.h"
-#include "mir/lockable_callback_wrapper.h"
-
-#include "timeout_frame_dropping_policy_factory.h"
-
-#include <cassert>
-#include <atomic>
-#include <chrono>
-#include <boost/throw_exception.hpp>
-
-namespace mc = mir::compositor;
-
-namespace
-{
-class TimeoutFrameDroppingPolicy : public mc::FrameDroppingPolicy
-{
-public:
-    TimeoutFrameDroppingPolicy(std::shared_ptr<mir::time::AlarmFactory> const& factory,
-                               std::chrono::milliseconds timeout,
-                               std::unique_ptr<mir::LockableCallback> drop_frame);
-
-    void swap_now_blocking() override;
-    void swap_unblocked() override;
-
-private:
-    std::chrono::milliseconds const timeout;
-    std::atomic<unsigned int> pending_swaps;
-
-    // Ensure alarm gets destroyed first so its handler does not access dead
-    // objects.
-    std::unique_ptr<mir::time::Alarm> const alarm;
-};
-
-TimeoutFrameDroppingPolicy::TimeoutFrameDroppingPolicy(std::shared_ptr<mir::time::AlarmFactory> const& factory,
-                                                       std::chrono::milliseconds timeout,
-                                                       std::unique_ptr<mir::LockableCallback> callback)
-    : timeout{timeout},
-      pending_swaps{0},
-      alarm{factory->create_alarm(
-          std::make_unique<mir::LockableCallbackWrapper>(std::move(callback),
-              [this] { assert(pending_swaps.load() > 0); },
-              [this] { if (--pending_swaps > 0) alarm->reschedule_in(this->timeout);} ))}
-{
-}
-
-void TimeoutFrameDroppingPolicy::swap_now_blocking()
-{
-    if (pending_swaps++ == 0)
-        alarm->reschedule_in(timeout);
-}
-
-void TimeoutFrameDroppingPolicy::swap_unblocked()
-{
-    if (alarm->state() != mir::time::Alarm::cancelled && alarm->cancel())
-    {
-        if (--pending_swaps > 0)
-        {
-            alarm->reschedule_in(timeout);
-        }
-    }
-}
-}
-
-mc::TimeoutFrameDroppingPolicyFactory::TimeoutFrameDroppingPolicyFactory(
-    std::shared_ptr<mir::time::AlarmFactory> const& timer,
-    std::chrono::milliseconds timeout)
-    : factory{timer},
-      timeout{timeout}
-{
-}
-
-std::unique_ptr<mc::FrameDroppingPolicy>
-mc::TimeoutFrameDroppingPolicyFactory::create_policy(std::unique_ptr<LockableCallback> drop_frame) const
-{
-    return std::make_unique<TimeoutFrameDroppingPolicy>(factory, timeout, std::move(drop_frame));
-}

=== removed file 'src/server/compositor/timeout_frame_dropping_policy_factory.h'
--- src/server/compositor/timeout_frame_dropping_policy_factory.h	2017-01-18 02:29:37 +0000
+++ src/server/compositor/timeout_frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-
-#ifndef MIR_COMPOSITOR_TIMEOUT_FRAME_DROPPING_POLICY_FACTORY_H_
-#define MIR_COMPOSITOR_TIMEOUT_FRAME_DROPPING_POLICY_FACTORY_H_
-
-#include "mir/compositor/frame_dropping_policy_factory.h"
-#include "mir/time/alarm_factory.h"
-
-#include <memory>
-#include <chrono>
-
-namespace mir
-{
-namespace compositor
-{
-
-/**
- * \brief Creator of timeout-based FrameDroppingPolicies
- */
-class TimeoutFrameDroppingPolicyFactory : public FrameDroppingPolicyFactory
-{
-public:
-    /**
-     * \param factory Factory which can create alarms used to schedule frame drops.
-     * \param timeout Number of milliseconds to wait before dropping a frame
-     */
-    TimeoutFrameDroppingPolicyFactory(
-        std::shared_ptr<mir::time::AlarmFactory> const& factory,
-        std::chrono::milliseconds timeout);
-
-    std::unique_ptr<FrameDroppingPolicy> create_policy(
-        std::unique_ptr<LockableCallback> drop_frame) const override;
-private:
-    std::shared_ptr<mir::time::AlarmFactory> const factory;
-    std::chrono::milliseconds timeout;
-};
-
-}
-}
-
-#endif // MIR_COMPOSITOR_TIMEOUT_FRAME_DROPPING_POLICY_FACTORY_FACTORY_H_

=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2017-04-13 07:00:27 +0000
+++ src/server/symbols.map	2017-05-02 09:09:50 +0000
@@ -861,7 +861,6 @@
     mir::DefaultServerConfiguration::the_event_filter_chain_dispatcher*;
     mir::DefaultServerConfiguration::the_fatal_error_strategy*;
     mir::DefaultServerConfiguration::the_focus_controller*;
-    mir::DefaultServerConfiguration::the_frame_dropping_policy_factory*;
     mir::DefaultServerConfiguration::the_frontend_display_changer*;
     mir::DefaultServerConfiguration::the_frontend_shell*;
     mir::DefaultServerConfiguration::the_gl_config*;

=== modified file 'tests/acceptance-tests/test_client_surface_swap_buffers.cpp'
--- tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2017-04-13 07:00:27 +0000
+++ tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2017-05-02 09:09:50 +0000
@@ -26,6 +26,7 @@
 #include "mir/graphics/cursor.h"
 
 #include <gtest/gtest.h>
+#include <thread>
 
 namespace mtf = mir_test_framework;
 namespace mt = mir::test;
@@ -36,11 +37,6 @@
 
 namespace
 {
-void swap_buffers_callback(MirBufferStream*, void* ctx)
-{
-    auto buffers_swapped = static_cast<mt::Signal*>(ctx);
-    buffers_swapped->raise();
-}
 
 struct SurfaceSwapBuffers : mtf::ConnectedClientWithAWindow
 {
@@ -64,13 +60,25 @@
         mt::Signal buffers_swapped;
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-        mir_buffer_stream_swap_buffers(mir_window_get_buffer_stream(window), swap_buffers_callback, &buffers_swapped);
+        auto bs = mir_window_get_buffer_stream(window);
 #pragma GCC diagnostic pop
+
+        /*
+         * Since we're using client-side vsync now, it should always return on
+         * the swap interval regardless of whether the server actually used
+         * the frame.
+         */
+        std::thread attempt_swap([bs, &buffers_swapped]{
+            mir_buffer_stream_swap_buffers_sync(bs);
+            buffers_swapped.raise();
+        });
+
         /*
          * ASSERT instead of EXPECT, since if we continue we will block in future
          * mir client calls (e.g mir_connection_release).
          */
         ASSERT_TRUE(buffers_swapped.wait_for(std::chrono::seconds{20}));
+        attempt_swap.join();
     }
 }
 

=== removed file 'tests/include/mir/test/doubles/mock_frame_dropping_policy_factory.h'
--- tests/include/mir/test/doubles/mock_frame_dropping_policy_factory.h	2017-01-18 02:29:37 +0000
+++ tests/include/mir/test/doubles/mock_frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
@@ -1,104 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-
-#ifndef MIR_TEST_DOUBLES_MOCK_FRAME_DROPPING_POLICY_FACTORY_H_
-#define MIR_TEST_DOUBLES_MOCK_FRAME_DROPPING_POLICY_FACTORY_H_
-
-#include "mir/compositor/frame_dropping_policy_factory.h"
-#include "mir/compositor/frame_dropping_policy.h"
-
-#include "mir/test/gmock_fixes.h"
-
-#include <unordered_set>
-#include <functional>
-#include <memory>
-
-#include <gmock/gmock.h>
-
-namespace mc = mir::compositor;
-
-namespace mir
-{
-class LockableCallback;
-
-namespace test
-{
-namespace doubles
-{
-
-class MockFrameDroppingPolicyFactory;
-
-class MockFrameDroppingPolicy : public mc::FrameDroppingPolicy
-{
-public:
-    MockFrameDroppingPolicy(mir::LockableCallback* callback,
-        MockFrameDroppingPolicyFactory const* parent);
-    ~MockFrameDroppingPolicy();
-
-    MOCK_METHOD0(swap_now_blocking, void(void));
-    MOCK_METHOD0(swap_unblocked, void(void));
-
-    void trigger();
-
-private:
-    friend class MockFrameDroppingPolicyFactory;
-    void parent_destroyed();
-
-    std::shared_ptr<mir::LockableCallback> callback;
-    MockFrameDroppingPolicyFactory const* parent;
-};
-
-class MockFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
-{
-public:
-    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(
-        std::unique_ptr<mir::LockableCallback> callback) const override;
-
-    ~MockFrameDroppingPolicyFactory();
-
-    void trigger_policies() const;
-
-private:
-    friend class MockFrameDroppingPolicy;
-
-    void policy_destroyed(MockFrameDroppingPolicy* policy) const;
-    mutable std::unordered_set<MockFrameDroppingPolicy*> policies;
-};
-
-class FrameDroppingPolicyFactoryMock : public mc::FrameDroppingPolicyFactory
-{
-public:
-    MOCK_CONST_METHOD1(create_policy,
-        std::unique_ptr<mc::FrameDroppingPolicy>(mir::LockableCallback* callback));
-
-    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(
-        std::unique_ptr<mir::LockableCallback> callback) const override
-    {
-        return create_policy(callback.get());
-    }
-
-};
-
-}
-}
-}
-
-
-#endif // MIR_TEST_DOUBLES_MOCK_FRAME_DROPPING_POLICY_FACTORY_H_

=== removed file 'tests/include/mir/test/doubles/stub_frame_dropping_policy_factory.h'
--- tests/include/mir/test/doubles/stub_frame_dropping_policy_factory.h	2017-01-18 02:29:37 +0000
+++ tests/include/mir/test/doubles/stub_frame_dropping_policy_factory.h	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-
-#ifndef MIR_TEST_DOUBLES_STUB_FRAME_DROPPING_POLICY_FACTORY_H_
-#define MIR_TEST_DOUBLES_STUB_FRAME_DROPPING_POLICY_FACTORY_H_
-
-#include "mir/compositor/frame_dropping_policy_factory.h"
-#include "mir/compositor/frame_dropping_policy.h"
-
-namespace mc = mir::compositor;
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-class StubFrameDroppingPolicy : public mc::FrameDroppingPolicy
-{
-public:
-    void swap_now_blocking()
-    {
-    }
-    void swap_unblocked()
-    {
-    }
-};
-
-class StubFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
-{
-public:
-    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(
-        std::unique_ptr<mir::LockableCallback>) const override
-    {
-       return std::unique_ptr<mc::FrameDroppingPolicy>{new StubFrameDroppingPolicy};
-    }
-};
-
-}
-}
-}
-#endif // TEST_DOUBLES_STUB_FRAME_DROPPING_POLICY_FACTORY_H_

=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2017-01-18 02:29:37 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2017-05-02 09:09:50 +0000
@@ -16,7 +16,6 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/test/doubles/stub_frame_dropping_policy_factory.h"
 #include "multithread_harness.h"
 
 #include "src/server/compositor/stream.h"
@@ -34,7 +33,6 @@
 namespace mg = mir::graphics;
 namespace mt = mir::testing;
 namespace geom = mir::geometry;
-namespace mtd = mir::test::doubles;
 
 namespace
 {
@@ -43,8 +41,7 @@
 {
     void SetUp()
     {
-        mtd::StubFrameDroppingPolicyFactory policy_factory;
-        stream = std::make_shared<mc::Stream>(policy_factory,
+        stream = std::make_shared<mc::Stream>(
             std::make_shared<mc::BufferMap>(nullptr),
             geom::Size{380, 210}, mir_pixel_format_abgr_8888);
     }

=== modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
--- tests/integration-tests/test_buffer_scheduling.cpp	2017-03-13 08:12:52 +0000
+++ tests/integration-tests/test_buffer_scheduling.cpp	2017-05-02 09:09:50 +0000
@@ -30,7 +30,6 @@
 #include "mir/test/doubles/stub_client_buffer_factory.h"
 #include "mir/test/doubles/mock_client_buffer_factory.h"
 #include "mir/test/doubles/stub_buffer_allocator.h"
-#include "mir/test/doubles/mock_frame_dropping_policy_factory.h"
 #include "mir/test/fake_shared.h"
 #include "mir_protobuf.pb.h"
 #include <gtest/gtest.h>
@@ -473,7 +472,6 @@
         sink = std::make_shared<StubEventSink>(ipc);
         map = std::make_shared<mc::BufferMap>(sink);
         auto submit_stream = std::make_shared<mc::Stream>(
-            drop_policy,
             map,
             geom::Size{100,100},
             mir_pixel_format_abgr_8888);
@@ -519,7 +517,6 @@
         consumer->set_framedropping(false);
     }
 
-    mtd::MockFrameDroppingPolicyFactory drop_policy;
     mtd::MockClientBufferFactory client_buffer_factory;
     mtd::StubBufferAllocator server_buffer_factory;
     mg::BufferProperties properties{geom::Size{3,3}, mir_pixel_format_abgr_8888, mg::BufferUsage::hardware};
@@ -805,36 +802,6 @@
     }
 }
 
-// Regression test for LP: #1396006
-TEST_P(WithTwoOrMoreBuffers, framedropping_policy_never_drops_newest_frame)
-{
-    for(auto i = 0; i < nbuffers; i++)
-        producer->produce();
-    drop_policy.trigger_policies();
-    producer->produce();
-
-    auto production_log = producer->production_log();
-    ASSERT_THAT(production_log, SizeIs(nbuffers + 1));
-    EXPECT_THAT(production_log[nbuffers], Not(Eq(production_log[nbuffers - 1]))); 
-}
-
-//TODO: (kdub) switch this test back to 2 buffers when we have timeout framedropping for NBS and nbuffers == 2 
-TEST_P(WithThreeOrMoreBuffers, client_is_unblocked_after_policy_is_triggered)
-{
-    producer->produce();
-    consumer->consume();
-
-    for(auto i = 0; i < nbuffers; i++)
-        producer->produce();
-    drop_policy.trigger_policies();
-    producer->produce();
-
-    auto production_log = producer->production_log();
-    ASSERT_THAT(production_log, SizeIs(nbuffers + 2));
-    EXPECT_THAT(production_log[nbuffers].blockage, Eq(Access::blocked));
-    EXPECT_THAT(production_log[nbuffers + 1].blockage, Eq(Access::unblocked));
-}
-
 TEST_P(WithTwoOrMoreBuffers, client_is_not_woken_by_compositor_release)
 {
     // If early release is accidentally active, make sure we see it. But it

=== modified file 'tests/integration-tests/test_server_shutdown.cpp'
--- tests/integration-tests/test_server_shutdown.cpp	2017-04-13 07:00:27 +0000
+++ tests/integration-tests/test_server_shutdown.cpp	2017-05-02 09:09:50 +0000
@@ -31,7 +31,6 @@
 #include "mir_test_framework/testing_server_configuration.h"
 
 #include "mir/test/doubles/null_display_buffer_compositor_factory.h"
-#include "mir/test/doubles/stub_frame_dropping_policy_factory.h"
 
 #include "mir/test/doubles/stub_renderer.h"
 
@@ -126,12 +125,6 @@
             return display_buffer_compositor_factory(
                 [] { return std::make_shared<mtd::NullDisplayBufferCompositorFactory>(); });
         }
-        // Don't drop frames, so the clients can block waiting for a buffer
-        std::shared_ptr<mc::FrameDroppingPolicyFactory> the_frame_dropping_policy_factory() override
-        {
-            return frame_dropping_policy_factory(
-                [] { return std::make_shared<mtd::StubFrameDroppingPolicyFactory>(); });
-        }
     };
     server_configuration.reset(new ServerConfig{});
 

=== modified file 'tests/integration-tests/test_submit_buffer.cpp'
--- tests/integration-tests/test_submit_buffer.cpp	2017-04-13 07:00:27 +0000
+++ tests/integration-tests/test_submit_buffer.cpp	2017-05-02 09:09:50 +0000
@@ -22,7 +22,6 @@
 #include "mir_test_framework/any_surface.h"
 #include "mir/test/doubles/stub_buffer.h"
 #include "mir/test/doubles/stub_buffer_allocator.h"
-#include "mir/test/doubles/stub_frame_dropping_policy_factory.h"
 #include "mir/test/doubles/stub_display.h"
 #include "mir/test/doubles/null_platform.h"
 #include "mir/graphics/buffer_id.h"
@@ -81,7 +80,7 @@
         mf::BufferStreamId, std::shared_ptr<mf::ClientBuffers> const& sink,
         mg::BufferProperties const& properties) override
     {
-        return std::make_shared<mc::Stream>(factory, sink, properties.size, properties.format);
+        return std::make_shared<mc::Stream>(sink, properties.size, properties.format);
     }
 
     std::shared_ptr<mf::ClientBuffers> create_buffer_map(std::shared_ptr<mf::BufferSink> const& sink) override
@@ -164,7 +163,6 @@
     }
 
     std::vector<mg::BufferID> const buffer_id_seq;
-    mtd::StubFrameDroppingPolicyFactory factory;
 };
 
 struct StubBufferPacker : public mg::PlatformIpcOperations

=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2017-02-15 14:45:41 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2017-05-02 09:09:50 +0000
@@ -33,7 +33,6 @@
 #include "mir/test/doubles/stub_display_buffer.h"
 #include "mir/test/doubles/stub_buffer.h"
 #include "mir/test/doubles/null_display_sync_group.h"
-#include "mir/test/doubles/stub_frame_dropping_policy_factory.h"
 #include "mir/test/doubles/mock_event_sink.h"
 #include "mir/test/doubles/stub_buffer_allocator.h"
 
@@ -125,7 +124,7 @@
     SurfaceStackCompositor() :
         timeout{std::chrono::system_clock::now() + std::chrono::seconds(5)},
         buffers(std::make_shared<mc::BufferMap>(std::make_shared<NiceMock<mtd::MockEventSink>>())),
-        stream(std::make_shared<mc::Stream>(policy_factory, buffers, geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888 )),
+        stream(std::make_shared<mc::Stream>(buffers, geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888 )),
         mock_buffer_stream(std::make_shared<NiceMock<mtd::MockBufferStream>>()),
         streams({ { stream, {0,0}, {} } }),
         stub_surface{std::make_shared<ms::BasicSurface>(
@@ -141,7 +140,6 @@
         ON_CALL(*mock_buffer_stream, lock_compositor_buffer(_))
             .WillByDefault(Return(mt::fake_shared(*stub_buffer)));
     }
-    mtd::StubFrameDroppingPolicyFactory policy_factory;
     std::shared_ptr<ms::SceneReport> null_scene_report{mr::null_scene_report()};
     ms::SurfaceStack stack{null_scene_report};
     std::shared_ptr<mc::CompositorReport> null_comp_report{mr::null_compositor_report()};

=== modified file 'tests/mir_test_doubles/CMakeLists.txt'
--- tests/mir_test_doubles/CMakeLists.txt	2017-04-21 03:08:25 +0000
+++ tests/mir_test_doubles/CMakeLists.txt	2017-05-02 09:09:50 +0000
@@ -15,7 +15,6 @@
   TEST_UTILS_SRCS
 
   mock_input_device.cpp
-  mock_frame_dropping_policy_factory.cpp
   mock_timer.cpp
   test_protobuf_client.cpp
   test_protobuf_socket_server.cpp

=== removed file 'tests/mir_test_doubles/mock_frame_dropping_policy_factory.cpp'
--- tests/mir_test_doubles/mock_frame_dropping_policy_factory.cpp	2017-01-18 02:29:37 +0000
+++ tests/mir_test_doubles/mock_frame_dropping_policy_factory.cpp	1970-01-01 00:00:00 +0000
@@ -1,78 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-#include "mir/test/doubles/mock_frame_dropping_policy_factory.h"
-
-#include "mir/lockable_callback.h"
-
-#include <mutex>
-
-namespace mc = mir::compositor;
-namespace mtd = mir::test::doubles;
-
-mtd::MockFrameDroppingPolicy::MockFrameDroppingPolicy(
-    mir::LockableCallback* callback,
-    MockFrameDroppingPolicyFactory const* parent)
-    : callback{callback},
-      parent{parent}
-{
-}
-
-mtd::MockFrameDroppingPolicy::~MockFrameDroppingPolicy()
-{
-    if (parent)
-        parent->policy_destroyed(this);
-}
-
-void mtd::MockFrameDroppingPolicy::trigger()
-{
-    auto& handler = *callback;
-    std::lock_guard<LockableCallback> lock{handler};
-    handler();
-}
-
-void mtd::MockFrameDroppingPolicy::parent_destroyed()
-{
-    parent = nullptr;
-}
-
-std::unique_ptr<mc::FrameDroppingPolicy>
-mtd::MockFrameDroppingPolicyFactory::create_policy(std::unique_ptr<mir::LockableCallback> callback) const
-{
-    auto policy = new testing::NiceMock<MockFrameDroppingPolicy>{callback.release(), this};
-    policies.insert(policy);
-    return std::unique_ptr<mc::FrameDroppingPolicy>{policy};
-}
-
-mtd::MockFrameDroppingPolicyFactory::~MockFrameDroppingPolicyFactory()
-{
-    for (auto policy : policies)
-        policy->parent_destroyed();
-}
-
-void mtd::MockFrameDroppingPolicyFactory::trigger_policies() const
-{
-    for (auto policy : policies)
-        policy->trigger();
-}
-
-void mtd::MockFrameDroppingPolicyFactory::policy_destroyed(MockFrameDroppingPolicy* policy) const
-{
-    policies.erase(policy);
-}

=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
--- tests/unit-tests/compositor/CMakeLists.txt	2017-01-18 02:29:37 +0000
+++ tests/unit-tests/compositor/CMakeLists.txt	2017-05-02 09:09:50 +0000
@@ -6,7 +6,6 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_occlusion.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_screencast_display_buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_compositing_screencast.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_timeout_frame_dropping_policy.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_monitor_arbiter.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_client_buffers.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_dropping_schedule.cpp

=== modified file 'tests/unit-tests/compositor/test_stream.cpp'
--- tests/unit-tests/compositor/test_stream.cpp	2017-03-14 02:26:28 +0000
+++ tests/unit-tests/compositor/test_stream.cpp	2017-05-02 09:09:50 +0000
@@ -19,7 +19,6 @@
 #include "mir/test/doubles/stub_buffer.h"
 #include "mir/test/doubles/stub_buffer_allocator.h"
 #include "mir/test/doubles/mock_event_sink.h"
-#include "mir/test/doubles/mock_frame_dropping_policy_factory.h"
 #include "mir/test/fake_shared.h"
 #include "src/server/compositor/stream.h"
 #include "mir/scene/null_surface_observer.h"
@@ -97,9 +96,7 @@
     std::vector<std::shared_ptr<mg::Buffer>> buffers;
     NiceMock<mtd::MockEventSink> mock_sink;
     MirPixelFormat construction_format{mir_pixel_format_rgb_565};
-    mtd::MockFrameDroppingPolicyFactory framedrop_factory;
     mc::Stream stream{
-        framedrop_factory,
         std::make_unique<StubBufferMap>(mock_sink, buffers), initial_size, construction_format};
 };
 }
@@ -266,116 +263,6 @@
     EXPECT_THAT(stream.pixel_format(), Eq(construction_format));
 }
 
-//confusingly, we have two framedrops. One is swapinterval zero, where old buffers are dropped as quickly as possible.
-//In non-framedropping mode, we drop based on a timeout according to a policy, mostly for screen-off scenarios.
-//
-namespace
-{
-struct MockPolicy : mc::FrameDroppingPolicy
-{
-    MOCK_METHOD0(swap_now_blocking, void(void));
-    MOCK_METHOD0(swap_unblocked, void(void));
-};
-}
-TEST_F(Stream, timer_starts_when_buffers_run_out_and_framedropping_disabled)
-{
-    auto policy = std::make_unique<MockPolicy>();
-    mtd::FrameDroppingPolicyFactoryMock policy_factory;
-    EXPECT_CALL(*policy, swap_now_blocking());
-    EXPECT_CALL(policy_factory, create_policy(_))
-        .WillOnce(InvokeWithoutArgs([&]{ return std::move(policy); }));
-    mc::Stream stream{
-        policy_factory,
-        std::make_unique<StubBufferMap>(mock_sink, buffers), initial_size, construction_format};
-    for (auto const& buffer : buffers)
-        stream.associate_buffer(buffer->id());
-
-    for (auto& buffer : buffers)
-        stream.submit_buffer(buffer);
-}
-
-TEST_F(Stream, timer_does_not_start_when_no_associated_buffers)
-{
-    auto policy = std::make_unique<MockPolicy>();
-    mtd::FrameDroppingPolicyFactoryMock policy_factory;
-    EXPECT_CALL(*policy, swap_now_blocking())
-        .Times(0);
-    EXPECT_CALL(policy_factory, create_policy(_))
-        .WillOnce(InvokeWithoutArgs([&]{ return std::move(policy); }));
-    mc::Stream stream{
-        policy_factory,
-        std::make_unique<StubBufferMap>(mock_sink, buffers), initial_size, construction_format};
-    for (auto& buffer : buffers)
-        stream.submit_buffer(buffer);
-}
-
-TEST_F(Stream, timer_stops_if_a_buffer_is_available)
-{
-    auto policy = std::make_unique<MockPolicy>();
-    mtd::FrameDroppingPolicyFactoryMock policy_factory;
-    EXPECT_CALL(*policy, swap_now_blocking());
-    EXPECT_CALL(*policy, swap_unblocked());
-    EXPECT_CALL(policy_factory, create_policy(_))
-        .WillOnce(InvokeWithoutArgs([&]{ return std::move(policy); }));
-    mc::Stream stream{
-        policy_factory,
-        std::make_unique<StubBufferMap>(mock_sink, buffers), initial_size, construction_format};
-    for (auto const& buffer : buffers)
-        stream.associate_buffer(buffer->id());
-    for (auto& buffer : buffers)
-        stream.submit_buffer(buffer);
-    stream.lock_compositor_buffer(this);
-}
-
-TEST_F(Stream, triggering_policy_gives_a_buffer_back)
-{
-    for (auto& buffer : buffers)
-        stream.submit_buffer(buffer);
-    stream.lock_compositor_buffer(this);
-
-    Mock::VerifyAndClearExpectations(&mock_sink);
-    EXPECT_CALL(mock_sink, send_buffer(_,_,_));
-    framedrop_factory.trigger_policies();
-    Mock::VerifyAndClearExpectations(&mock_sink);
-}
-
-TEST_F(Stream, doesnt_drop_the_only_frame_when_arbiter_has_none)
-{
-    stream.submit_buffer(buffers[0]);
-    Mock::VerifyAndClearExpectations(&mock_sink);
-    EXPECT_CALL(mock_sink, send_buffer(_,_,_))
-        .Times(0);
-    framedrop_factory.trigger_policies();
-    Mock::VerifyAndClearExpectations(&mock_sink);
-}
-
-TEST_F(Stream, doesnt_drop_the_latest_frame_with_a_longer_queue)
-{
-    stream.submit_buffer(buffers[0]);
-    stream.lock_compositor_buffer(this);
-    stream.submit_buffer(buffers[1]);
-    stream.submit_buffer(buffers[2]);
-
-    Mock::VerifyAndClearExpectations(&mock_sink);
-    EXPECT_CALL(mock_sink, send_buffer(_,Ref(*buffers[1]),_))
-        .Times(1);
-    framedrop_factory.trigger_policies();
-    Mock::VerifyAndClearExpectations(&mock_sink);
-}
-
-TEST_F(Stream, doesnt_drop_the_latest_frame_with_a_2_buffer_queue)
-{
-    stream.submit_buffer(buffers[0]);
-    stream.lock_compositor_buffer(this);
-    stream.submit_buffer(buffers[1]);
-
-    Mock::VerifyAndClearExpectations(&mock_sink);
-    EXPECT_CALL(mock_sink, send_buffer(_,Ref(*buffers[1]),_))
-        .Times(0);
-    framedrop_factory.trigger_policies();
-    Mock::VerifyAndClearExpectations(&mock_sink);
-}
-
 TEST_F(Stream, returns_buffers_to_client_when_told_to_bring_queue_up_to_date)
 {
     stream.submit_buffer(buffers[0]);

=== removed file 'tests/unit-tests/compositor/test_timeout_frame_dropping_policy.cpp'
--- tests/unit-tests/compositor/test_timeout_frame_dropping_policy.cpp	2017-01-18 02:29:37 +0000
+++ tests/unit-tests/compositor/test_timeout_frame_dropping_policy.cpp	1970-01-01 00:00:00 +0000
@@ -1,196 +0,0 @@
-/*
- * Copyright © 2014-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: Christopher James Halse Rogers <[e-mail]>
- *              Alberto Aguirre <[e-mail]>
- */
-
-#include "src/server/compositor/timeout_frame_dropping_policy_factory.h"
-#include "mir/compositor/frame_dropping_policy.h"
-#include "mir/basic_callback.h"
-
-#include "mir/test/doubles/mock_timer.h"
-#include "mir/test/doubles/mock_lockable_callback.h"
-#include "mir/test/auto_unblock_thread.h"
-#include "mir/test/fake_shared.h"
-#include "mir/test/gmock_fixes.h"
-
-#include <stdexcept>
-#include <mutex>
-
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-namespace mc = mir::compositor;
-namespace mt = mir::test;
-namespace mtd = mir::test::doubles;
-
-namespace
-{
-class TimeoutFrameDroppingPolicy : public ::testing::Test
-{
-public:
-
-    void SetUp() override
-    {
-       clock = std::make_shared<mt::FakeClock>();
-       timer = std::make_shared<mtd::FakeTimer>(clock);
-       handler = std::make_unique<mir::BasicCallback>([this]{ frame_dropped = true; });
-    }
-
-    auto create_default_policy()
-    {
-        mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
-        return factory.create_policy(std::move(handler));
-    }
-
-protected:
-    std::shared_ptr<mt::FakeClock> clock;
-    std::shared_ptr<mtd::FakeTimer> timer;
-    std::chrono::milliseconds const timeout = std::chrono::milliseconds(1000);
-    std::unique_ptr<mir::BasicCallback> handler;
-    bool frame_dropped = false;
-};
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, does_not_fire_before_notified_of_block)
-{
-    auto policy = create_default_policy();
-
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_FALSE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, schedules_alarm_for_correct_timeout)
-{
-    auto policy = create_default_policy();
-    policy->swap_now_blocking();
-
-    clock->advance_time(timeout - std::chrono::milliseconds{1});
-    EXPECT_FALSE(frame_dropped);
-    clock->advance_time(std::chrono::milliseconds{2});
-    EXPECT_TRUE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, framedrop_callback_cancelled_by_unblock)
-{
-    auto policy = create_default_policy();
-
-    policy->swap_now_blocking();
-    policy->swap_unblocked();
-
-    clock->advance_time(timeout * 10);
-
-    EXPECT_FALSE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, policy_drops_one_frame_per_blocking_swap)
-{
-    auto policy = create_default_policy();
-
-    policy->swap_now_blocking();
-    policy->swap_now_blocking();
-    policy->swap_now_blocking();
-
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_TRUE(frame_dropped);
-
-    frame_dropped = false;
-    clock->advance_time(timeout + std::chrono::milliseconds{2});
-    EXPECT_TRUE(frame_dropped);
-
-    frame_dropped = false;
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_TRUE(frame_dropped);
-
-    frame_dropped = false;
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_FALSE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, policy_drops_frames_no_more_frequently_than_timeout)
-{
-    auto policy = create_default_policy();
-
-    policy->swap_now_blocking();
-    policy->swap_now_blocking();
-
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_TRUE(frame_dropped);
-
-    frame_dropped = false;
-    clock->advance_time(timeout - std::chrono::milliseconds{1});
-    EXPECT_FALSE(frame_dropped);
-    clock->advance_time(std::chrono::milliseconds{2});
-    EXPECT_TRUE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, newly_blocking_frame_doesnt_reset_timeout)
-{
-    auto policy = create_default_policy();
-
-    policy->swap_now_blocking();
-    clock->advance_time(timeout - std::chrono::milliseconds{1});
-
-    policy->swap_now_blocking();
-    clock->advance_time(std::chrono::milliseconds{2});
-    EXPECT_TRUE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, interspersed_timeouts_and_unblocks)
-{
-    auto policy = create_default_policy();
-
-    policy->swap_now_blocking();
-    policy->swap_now_blocking();
-    policy->swap_now_blocking();
-
-    /* First frame gets dropped... */
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_TRUE(frame_dropped);
-
-    /* ...Compositor gets its act in order and consumes a frame... */
-    frame_dropped = false;
-    policy->swap_unblocked();
-    clock->advance_time(timeout - std::chrono::milliseconds{1});
-    EXPECT_FALSE(frame_dropped);
-
-    /* ...but not a second frame, so third swap should trigger a timeout */
-    clock->advance_time(std::chrono::milliseconds{2});
-    EXPECT_TRUE(frame_dropped);
-
-    frame_dropped = false;
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-    EXPECT_FALSE(frame_dropped);
-}
-
-TEST_F(TimeoutFrameDroppingPolicy, policy_calls_lock_unlock_functions)
-{
-    using namespace testing;
-
-    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
-    auto handler = std::make_unique<mtd::MockLockableCallback>();
-    {
-        InSequence s;
-        EXPECT_CALL(*handler, lock());
-        EXPECT_CALL(*handler, functor());
-        EXPECT_CALL(*handler, unlock());
-    }
-
-    auto policy = factory.create_policy(std::move(handler));
-
-    policy->swap_now_blocking();
-    clock->advance_time(timeout + std::chrono::milliseconds{1});
-}

=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2017-03-14 02:26:28 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2017-05-02 09:09:50 +0000
@@ -31,7 +31,6 @@
 #include "mir/test/doubles/stub_buffer_stream_factory.h"
 #include "mir/test/doubles/stub_renderable.h"
 #include "mir/test/doubles/mock_buffer_stream.h"
-#include "mir/test/doubles/stub_frame_dropping_policy_factory.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -300,8 +299,7 @@
     };
 
     auto buffers = std::make_shared<StubBuffers>();
-    mtd::StubFrameDroppingPolicyFactory factory;
-    auto stream = std::make_shared<mc::Stream>(factory, buffers, geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888);
+    auto stream = std::make_shared<mc::Stream>(buffers, geom::Size{ 1, 1 }, mir_pixel_format_abgr_8888);
 
     auto surface = std::make_shared<ms::BasicSurface>(
         std::string("stub"),