compositor/Stream: Remove buffers_ready_for_compositor

The only internal user of this has been removed. QtMir is an *external* user
of this, but:
* Doesn't actually *need* this behaviour, and
* Needs significant work in this area anyway to update for 2.16's Platform changes

Author: RAOF

include/miroil/miroil/surface.h

@@ -44,7 +44,6 @@ class Surface
     void add_observer(std::shared_ptr<miroil::SurfaceObserver> const& observer);    
     void remove_observer(std::shared_ptr<miroil::SurfaceObserver> const& observer);
 
-    int  buffers_ready_for_compositor(void const* compositor_id) const;
     mir::graphics::RenderableList generate_renderables(miroil::CompositorID id) const; 
 
 

src/include/server/mir/compositor/buffer_stream.h

@@ -42,7 +42,6 @@ class BufferStream : public frontend::BufferStream
     virtual auto lock_compositor_buffer(void const* user_id) -> std::shared_ptr<graphics::Buffer> = 0;
     /// Logical size of the stream (may be different than buffer sizes if scaled)
     virtual auto stream_size() -> geometry::Size = 0;
-    virtual auto buffers_ready_for_compositor(void const* user_id) const -> int = 0;
     virtual auto has_submitted_buffer() const -> bool = 0;
 };
 

src/include/server/mir/scene/surface.h

@@ -64,7 +64,6 @@ class Surface :
     virtual geometry::Size window_size() const = 0;
 
     virtual graphics::RenderableList generate_renderables(compositor::CompositorID id) const = 0; 
-    virtual int buffers_ready_for_compositor(void const* compositor_id) const = 0;
 
     virtual MirWindowType type() const = 0;
     virtual MirWindowState state() const = 0;

src/miroil/surface.cpp

@@ -207,11 +207,6 @@ auto miroil::Surface::get_wrapped() const -> mir::scene::Surface*
     return wrapped.get();
 }
 
-int miroil::Surface::buffers_ready_for_compositor(void const* compositor_id) const
-{
-    return wrapped->buffers_ready_for_compositor(compositor_id);
-}
-
 mir::graphics::RenderableList miroil::Surface::generate_renderables(miroil::CompositorID id) const
 {
     return wrapped->generate_renderables(id);

src/server/compositor/stream.cpp

@@ -83,13 +83,6 @@ geom::Size mc::Stream::stream_size()
         roundf(state->latest_buffer_size.height.as_int() / state->scale_)};
 }
 
-int mc::Stream::buffers_ready_for_compositor(void const* id) const
-{
-    if (arbiter->buffer_ready_for(id))
-        return 1;
-    return 0;
-}
-
 bool mc::Stream::has_submitted_buffer() const
 {
     // Don't need to lock mutex because first_frame_posted is atomic

src/server/compositor/stream.h

@@ -44,7 +44,6 @@ class Stream : public BufferStream
     std::shared_ptr<graphics::Buffer>
         lock_compositor_buffer(void const* user_id) override;
     geometry::Size stream_size() override;
-    int buffers_ready_for_compositor(void const* user_id) const override;
     bool has_submitted_buffer() const override;
     void set_scale(float scale) override;
 

src/server/frontend_xwayland/scaled_buffer_stream.cpp

@@ -57,11 +57,6 @@ auto mf::ScaledBufferStream::stream_size() -> geometry::Size
     return inner->stream_size() * inv_scale;
 }
 
-auto mf::ScaledBufferStream::buffers_ready_for_compositor(void const* user_id) const -> int
-{
-    return inner->buffers_ready_for_compositor(user_id);
-}
-
 auto mf::ScaledBufferStream::has_submitted_buffer() const -> bool
 {
     return inner->has_submitted_buffer();

src/server/frontend_xwayland/scaled_buffer_stream.h

@@ -45,7 +45,6 @@ class ScaledBufferStream : public compositor::BufferStream
     /// @{
     auto lock_compositor_buffer(void const* user_id) -> std::shared_ptr<graphics::Buffer>;
     auto stream_size() -> geometry::Size;
-    auto buffers_ready_for_compositor(void const* user_id) const -> int;
     auto has_submitted_buffer() const -> bool;
     /// @}
 

src/server/scene/basic_surface.cpp

@@ -748,15 +748,6 @@ class SurfaceSnapshot : public mg::Renderable
 };
 }
 
-int ms::BasicSurface::buffers_ready_for_compositor(void const* id) const
-{
-    auto state = synchronised_state.lock();
-    auto max_buf = 0;
-    for (auto const& info : state->layers)
-        max_buf = std::max(max_buf, info.stream->buffers_ready_for_compositor(id));
-    return max_buf;
-}
-
 void ms::BasicSurface::consume(std::shared_ptr<MirEvent const> const& event)
 {
     observers->input_consumed(this, event);
@@ -1048,4 +1039,4 @@ void mir::scene::BasicSurface::linearised_track_outputs()
     {
         track_outputs();
     }
-}
+}

src/server/scene/basic_surface.h

@@ -118,7 +118,6 @@ class BasicSurface : public Surface
     bool visible() const override;
 
     graphics::RenderableList generate_renderables(compositor::CompositorID id) const override;
-    int buffers_ready_for_compositor(void const* compositor_id) const override;
 
     MirWindowType type() const override;
     MirWindowState state() const override;

tests/include/mir/test/doubles/stub_buffer_stream.h

@@ -47,8 +47,6 @@ class StubBufferStream : public compositor::BufferStream
         return geometry::Size();
     }
 
-    int buffers_ready_for_compositor(void const*) const override { return nready; }
-
     void submit_buffer(std::shared_ptr<graphics::Buffer> const& b) override
     {
         if (b) ++nready;

tests/include/mir/test/doubles/stub_surface.h

@@ -49,7 +49,6 @@ struct StubSurface : scene::Surface
     void set_transformation(glm::mat4 const&) override {}
     bool visible() const override { return false; }
     graphics::RenderableList generate_renderables(compositor::CompositorID) const override { return {}; }
-    int buffers_ready_for_compositor(void const*) const override { return 0; }
     MirWindowType type() const override { return mir_window_type_normal; }
     auto state_tracker() const -> scene::SurfaceStateTracker override
     {

tests/unit-tests/compositor/test_stream.cpp

@@ -50,16 +50,6 @@ struct Stream : Test
 };
 }
 
-TEST_F(Stream, indicates_buffers_ready_when_dropping)
-{
-    for(auto& buffer : buffers)
-        stream.submit_buffer(buffer);
-
-    EXPECT_THAT(stream.buffers_ready_for_compositor(this), Eq(1));
-    stream.lock_compositor_buffer(this);
-    EXPECT_THAT(stream.buffers_ready_for_compositor(this), Eq(0));
-}
-
 TEST_F(Stream, tracks_has_buffer)
 {
     EXPECT_FALSE(stream.has_submitted_buffer());
@@ -82,7 +72,6 @@ TEST_F(Stream, frame_callback_is_called_without_scheduling_lock)
     stream.set_frame_posted_callback(
         [this](auto)
         {
-            EXPECT_THAT(stream.buffers_ready_for_compositor(this), Eq(1));
             EXPECT_TRUE(stream.has_submitted_buffer());
         });
     stream.submit_buffer(buffers[0]);

tests/unit-tests/scene/test_basic_surface.cpp

@@ -1511,35 +1511,6 @@ TEST_F(BasicSurfaceTest, visibility_matches_produced_list)
     EXPECT_THAT(renderables.size(), Eq(2));
 }
 
-TEST_F(BasicSurfaceTest, buffers_ready_correctly_reported)
-{
-    using namespace testing;
-    auto buffer_stream0 = std::make_shared<NiceMock<mtd::MockBufferStream>>();
-    auto buffer_stream1 = std::make_shared<NiceMock<mtd::MockBufferStream>>();
-    EXPECT_CALL(*mock_buffer_stream, buffers_ready_for_compositor(_))
-        .WillOnce(Return(0))
-        .WillOnce(Return(0))
-        .WillOnce(Return(2));
-    EXPECT_CALL(*buffer_stream0, buffers_ready_for_compositor(_))
-        .WillOnce(Return(1))
-        .WillOnce(Return(0))
-        .WillOnce(Return(1));
-    EXPECT_CALL(*buffer_stream1, buffers_ready_for_compositor(_))
-        .WillOnce(Return(3))
-        .WillOnce(Return(0))
-        .WillOnce(Return(1));
-
-    std::list<ms::StreamInfo> streams = {
-        { mock_buffer_stream, {0,0}, {} },
-        { buffer_stream0, {0,0}, {} },
-        { buffer_stream1, {0,0}, {} },
-    };
-    surface.set_streams(streams);
-    EXPECT_THAT(surface.buffers_ready_for_compositor(this), Eq(3));
-    EXPECT_THAT(surface.buffers_ready_for_compositor(this), Eq(0));
-    EXPECT_THAT(surface.buffers_ready_for_compositor(this), Eq(2));
-}
-
 TEST_F(BasicSurfaceTest, buffer_streams_produce_correctly_sized_renderables)
 {
     using namespace testing;