Merge lp:~alan-griffiths/miral/monitor-outputs into lp:miral

[Alan Griffiths]

Introducing ActiveOutputsMonitor to track the active outputs

[Gerry Boland (gerboland)]

+++ include/miral/active_outputs.h
+class ActiveOutputsListener
+ virtual void advise_update_output(Output const& updated, Output const& original);
this is great to have, thank you

"Outputs" is replacing "Display"? /me ambivalent, but your team may have stronger opinions :)

+class ActiveOutputsMonitor
+ void process_outputs(std::function<void(std::vector<Output> const& outputs)> const& functor) const;
Mir uses the for_each_output(functor) style usually, has that been changing?

+++ include/miral/output.h
+ /// The physical size of the output.
+ auto physical_size() const -> PhysicalSize;
What units? mm?

+ auto orientaton() const -> MirOrientation;
Typo

=== modified file 'miral/CMakeLists.txt'
+ active_outputs.cpp ../include/miral/active_outputs.h
use ${CMAKE_SOURCE_DIR} for consistency

+++ miral/output.cpp
+auto miral::equivalent_display_area(Output const& lhs, Output const& rhs) -> bool
I'm fine with this for a first cut. For later I'd prefer operations like orientation or resolution change just cause an output update, not an add/remove.

+ if (lhs_bad || rhs_bad) return lhs_bad == rhs_bad;
if both outputs bad, this returns true. Are 2 invalid outputs equivalent?

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

> "Outputs" is replacing "Display"? /me ambivalent, but your team may have
> stronger opinions :)

I guess I'll ask.
...
> +++ miral/output.cpp
> +auto miral::equivalent_display_area(Output const& lhs, Output const& rhs) ->
> bool
> I'm fine with this for a first cut. For later I'd prefer operations like
> orientation or resolution change just cause an output update, not an
> add/remove.

I don't see the connection between the code and your comment. For the latter, see
ActiveOutputs.when_base_configuration_is_updated_listener_is_advised which uses an orientation change to test for an output update.

> + if (lhs_bad || rhs_bad) return lhs_bad == rhs_bad;
> if both outputs bad, this returns true. Are 2 invalid outputs equivalent?

IMO They have equivalent display areas.

[lp:~alan-griffiths/miral/monitor-outputs]

240. By Alan Griffiths on 2016-07-22

merge lp:miral

241. By Alan Griffiths on 2016-07-22

for_each_output() is a more consistent name

242. By Alan Griffiths on 2016-07-22

Oh for a standard Units library

243. By Alan Griffiths on 2016-07-22

Fix typo

244. By Alan Griffiths on 2016-07-22

Consistency

245. By Alan Griffiths on 2016-07-22

re-sync working copy

[Alan Griffiths (alan-griffiths)]

> > "Outputs" is replacing "Display"? /me ambivalent, but your team may have
> > stronger opinions :)
>
> I guess I'll ask.

Actually, the Mir codebase uses output too. E.g. DisplayConfiguration::for_each_output()

[Gerry Boland (gerboland)]

LGTM

review: Approve

=== added file 'include/miral/active_outputs.h'
--- include/miral/active_outputs.h	1970-01-01 00:00:00 +0000
+++ include/miral/active_outputs.h	2016-07-22 11:21:29 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_ACTIVE_OUTPUTS_H
+#define MIRAL_ACTIVE_OUTPUTS_H
+
+#include <memory>
+#include <vector>
+
+namespace mir { class Server; }
+
+namespace miral
+{
+class Output;
+
+class ActiveOutputsListener
+{
+public:
+    ActiveOutputsListener() = default;
+
+    /// before any related calls begin
+    virtual void advise_begin();
+
+    /// after any related calls end
+    virtual void advise_end();
+
+    virtual void advise_create_output(Output const& output);
+    virtual void advise_update_output(Output const& updated, Output const& original);
+    virtual void advise_delete_output(Output const& output);
+
+protected:
+    virtual ~ActiveOutputsListener() = default;
+    ActiveOutputsListener(ActiveOutputsListener const&) = delete;
+    ActiveOutputsListener operator=(ActiveOutputsListener const&) = delete;
+};
+
+class ActiveOutputsMonitor
+{
+public:
+    ActiveOutputsMonitor();
+    ~ActiveOutputsMonitor();
+    ActiveOutputsMonitor(ActiveOutputsMonitor const&);
+    ActiveOutputsMonitor& operator=(ActiveOutputsMonitor const&);
+
+    void add_listener(ActiveOutputsListener* listener);
+    void delete_listener(ActiveOutputsListener* listener);
+
+    void operator()(mir::Server& server);
+
+    void for_each_output(std::function<void(std::vector<Output> const& outputs)> const& functor) const;
+
+private:
+    struct Self;
+    std::shared_ptr<Self> self;
+};
+}
+
+#endif //MIRAL_ACTIVE_OUTPUTS_H

=== added file 'include/miral/output.h'
--- include/miral/output.h	1970-01-01 00:00:00 +0000
+++ include/miral/output.h	2016-07-22 11:21:29 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_OUTPUT_H
+#define MIRAL_OUTPUT_H
+
+#include <mir_toolkit/common.h>
+
+#include <mir/geometry/rectangle.h>
+#include <mir/int_wrapper.h>
+
+#include <memory>
+
+namespace mir { namespace graphics { struct DisplayConfigurationOutput; } }
+
+namespace miral
+{
+using namespace mir::geometry;
+
+class Output
+{
+public:
+
+    struct PhysicalSizeMM { int width; int height; };
+
+    enum class Type
+    {
+        unknown,
+        vga,
+        dvii,
+        dvid,
+        dvia,
+        composite,
+        svideo,
+        lvds,
+        component,
+        ninepindin,
+        displayport,
+        hdmia,
+        hdmib,
+        tv,
+        edp
+    };
+
+    explicit Output(const mir::graphics::DisplayConfigurationOutput &output);
+    Output(Output const&);
+    Output& operator=(Output const&);
+    ~Output();
+
+    /// The type of the output.
+    auto type() const -> Type;
+
+    /// The physical size of the output.
+    auto physical_size_mm() const -> PhysicalSizeMM;
+
+    /// Whether the output is connected.
+    auto connected() const -> bool;
+
+    /// Whether the output is used in the configuration.
+    auto used() const -> bool;
+
+    /// The current output pixel format.
+    auto pixel_format() const -> MirPixelFormat;
+    
+    /// refresh_rate in Hz
+    auto refresh_rate() const -> double;
+
+    /// Current power mode
+    auto power_mode() const -> MirPowerMode;
+
+    auto orientation() const -> MirOrientation;
+
+    /// Requested scale factor for this output, for HiDPI support
+    auto scale() const -> float;
+
+    /// Form factor of this output; phone display, tablet, monitor, TV, projector...
+    auto form_factor() const -> MirFormFactor;
+
+    /// The logical rectangle occupied by the output, based on its position,
+    /// current mode and orientation (rotation)
+    auto extents() const -> Rectangle;
+
+    auto valid() const -> bool;
+
+    auto is_same_output(Output const& other) const -> bool;
+
+private:
+    std::shared_ptr<mir::graphics::DisplayConfigurationOutput> self;
+};
+
+bool operator==(Output::PhysicalSizeMM const& lhs, Output::PhysicalSizeMM const& rhs);
+inline bool operator!=(Output::PhysicalSizeMM const& lhs, Output::PhysicalSizeMM const& rhs)
+{ return !(lhs == rhs); }
+
+auto equivalent_display_area(Output const& lhs, Output const& rhs) -> bool;
+}
+
+#endif //MIRAL_OUTPUT_H

=== modified file 'include/miral/window.h'
--- include/miral/window.h	2016-06-09 02:09:01 +0000
+++ include/miral/window.h	2016-07-22 11:21:29 +0000
@@ -35,7 +35,7 @@
 namespace mir
 {
 namespace scene { class Surface; }
-namespace shell { class StreamSpecification; }
+namespace shell { struct StreamSpecification; }
 }
 
 namespace miral

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-06-16 10:21:28 +0000
+++ miral/CMakeLists.txt	2016-07-22 11:21:29 +0000
@@ -3,12 +3,14 @@
 include_directories(include SYSTEM ${MIRSERVER_INCLUDE_DIRS})
 
 add_library(miral SHARED
+    active_outputs.cpp                  ${CMAKE_SOURCE_DIR}/include/miral/active_outputs.h
     application.cpp                     ${CMAKE_SOURCE_DIR}/include/miral/application.h
     application_authorizer.cpp          ${CMAKE_SOURCE_DIR}/include/miral/application_authorizer.h
     application_info.cpp                ${CMAKE_SOURCE_DIR}/include/miral/application_info.h
     canonical_window_manager.cpp        ${CMAKE_SOURCE_DIR}/include/miral/canonical_window_manager.h
     runner.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/runner.h
     display_configuration_option.cpp    ${CMAKE_SOURCE_DIR}/include/miral/display_configuration_option.h
+    output.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/output.h
     quit_on_ctrl_alt_bksp.cpp           ${CMAKE_SOURCE_DIR}/include/miral/quit_on_ctrl_alt_bksp.h
     window.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/window.h
     window_info.cpp                     ${CMAKE_SOURCE_DIR}/include/miral/window_info.h

=== added file 'miral/active_outputs.cpp'
--- miral/active_outputs.cpp	1970-01-01 00:00:00 +0000
+++ miral/active_outputs.cpp	2016-07-22 11:21:29 +0000
@@ -0,0 +1,131 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "miral/active_outputs.h"
+#include "miral/output.h"
+
+#include <mir/graphics/display_configuration_report.h>
+#include <mir/graphics/display_configuration.h>
+#include <mir/server.h>
+
+#include <algorithm>
+#include <mutex>
+#include <vector>
+
+void miral::ActiveOutputsListener::advise_begin() {}
+void miral::ActiveOutputsListener::advise_end() {}
+void miral::ActiveOutputsListener::advise_create_output(Output const& /*output*/) {}
+void miral::ActiveOutputsListener::advise_update_output(Output const& /*updated*/, Output const& /*original*/) {}
+void miral::ActiveOutputsListener::advise_delete_output(Output const& /*output*/) {}
+
+struct miral::ActiveOutputsMonitor::Self : mir::graphics::DisplayConfigurationReport
+{
+    virtual void initial_configuration(mir::graphics::DisplayConfiguration const& configuration) override;
+    virtual void new_configuration(mir::graphics::DisplayConfiguration const& configuration) override;
+
+    std::mutex mutex;
+    std::vector<ActiveOutputsListener*> listeners;
+    std::vector<Output> outputs;
+};
+
+miral::ActiveOutputsMonitor::ActiveOutputsMonitor() :
+    self{std::make_shared<Self>()}
+{
+}
+
+miral::ActiveOutputsMonitor::~ActiveOutputsMonitor() = default;
+miral::ActiveOutputsMonitor::ActiveOutputsMonitor(ActiveOutputsMonitor const&) = default;
+miral::ActiveOutputsMonitor& miral::ActiveOutputsMonitor::operator=(ActiveOutputsMonitor const&) = default;
+
+void miral::ActiveOutputsMonitor::add_listener(ActiveOutputsListener* listener)
+{
+    std::lock_guard<decltype(self->mutex)> lock{self->mutex};
+
+    self->listeners.push_back(listener);
+}
+
+void miral::ActiveOutputsMonitor::delete_listener(ActiveOutputsListener* listener)
+{
+    std::lock_guard<decltype(self->mutex)> lock{self->mutex};
+
+    auto const new_end = std::remove(self->listeners.begin(), self->listeners.end(), listener);
+    self->listeners.erase(new_end, self->listeners.end());
+}
+
+void miral::ActiveOutputsMonitor::operator()(mir::Server& server)
+{
+    std::lock_guard<decltype(self->mutex)> lock{self->mutex};
+
+    server.override_the_display_configuration_report([this]{ return self; });
+}
+
+void miral::ActiveOutputsMonitor::for_each_output(
+    std::function<void(std::vector<Output> const& outputs)> const& functor) const
+{
+    std::lock_guard<decltype(self->mutex)> lock{self->mutex};
+    functor(self->outputs);
+}
+
+void miral::ActiveOutputsMonitor::Self::initial_configuration(mir::graphics::DisplayConfiguration const& configuration)
+{
+    new_configuration(configuration);
+}
+
+void miral::ActiveOutputsMonitor::Self::new_configuration(mir::graphics::DisplayConfiguration const& configuration)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    decltype(outputs) current_outputs;
+
+    for (auto const l : listeners)
+        l->advise_begin();
+
+    configuration.for_each_output([&current_outputs, this](mir::graphics::DisplayConfigurationOutput const& output)
+        {
+            Output o{output};
+            auto op = find_if(begin(outputs), end(outputs), [&](Output const& oo) { return oo.is_same_output(o); });
+
+
+            if (op == end(outputs))
+            {
+                for (auto const l : listeners)
+                    l->advise_create_output(o);
+            }
+            else if (!equivalent_display_area(o, *op))
+            {
+                for (auto const l : listeners)
+                    l->advise_update_output(o, *op);
+            }
+
+            current_outputs.push_back(o);
+        });
+
+    for (auto const& o : outputs)
+    {
+        auto op = find_if(begin(current_outputs), end(current_outputs), [&](Output const& oo)
+            { return oo.is_same_output(o); });
+
+        if (op == end(current_outputs))
+            for (auto const l : listeners)
+                l->advise_delete_output(o);
+    }
+
+    current_outputs.swap(outputs);
+    for (auto const l : listeners)
+        l->advise_end();
+}

=== added file 'miral/output.cpp'
--- miral/output.cpp	1970-01-01 00:00:00 +0000
+++ miral/output.cpp	2016-07-22 11:21:29 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "miral/output.h"
+
+#include <mir/graphics/display_configuration.h>
+
+miral::Output::Output(const mir::graphics::DisplayConfigurationOutput& output) :
+    self{std::make_shared<mir::graphics::DisplayConfigurationOutput>(output)}
+{
+}
+
+miral::Output::Output(Output const&) = default;
+miral::Output& miral::Output::operator=(Output const&) = default;
+miral::Output::~Output() = default;
+
+auto miral::Output::type() const -> Type
+{
+    return Type(self->type);
+}
+
+auto miral::Output::physical_size_mm() const -> PhysicalSizeMM
+{
+    auto const& size = self->physical_size_mm;
+    return PhysicalSizeMM{size.width.as_int(), size.height.as_int()};
+}
+
+auto miral::Output::connected() const -> bool
+{
+    return self->connected;
+}
+
+auto miral::Output::used() const -> bool
+{
+    return self->used;
+}
+
+auto miral::Output::pixel_format() const -> MirPixelFormat
+{
+    return self->current_format;
+}
+
+auto miral::Output::refresh_rate() const -> double
+{
+    return self->modes[self->current_mode_index].vrefresh_hz;
+}
+
+auto miral::Output::power_mode() const -> MirPowerMode
+{
+    return self->power_mode;
+}
+
+auto miral::Output::orientation() const -> MirOrientation
+{
+    return self->orientation;
+}
+
+auto miral::Output::scale() const -> float
+{
+    return self->scale;
+}
+
+auto miral::Output::form_factor() const -> MirFormFactor
+{
+    return self->form_factor;
+}
+
+auto miral::Output::extents() const -> Rectangle
+{
+    return Rectangle{self->top_left, self->modes[self->current_mode_index].size};
+
+}
+
+auto miral::Output::valid() const -> bool
+{
+    return self->valid();
+}
+
+auto miral::Output::is_same_output(Output const& other) const -> bool
+{
+    return self->card_id == other.self->card_id && self->id == other.self->id;
+}
+
+bool miral::operator==(Output::PhysicalSizeMM const& lhs, Output::PhysicalSizeMM const& rhs)
+{
+    return lhs.width == rhs.width && lhs.height == rhs.height;
+}
+
+auto miral::equivalent_display_area(Output const& lhs, Output const& rhs) -> bool
+{
+    // Eliminate the cases where one or both output isn't available
+    auto const lhs_bad = !lhs.valid() || !lhs.used() || !lhs.connected() || lhs.power_mode() != mir_power_mode_on;
+    auto const rhs_bad = !rhs.valid() || !rhs.used() || !rhs.connected() || rhs.power_mode() != mir_power_mode_on;
+    if (lhs_bad || rhs_bad) return lhs_bad == rhs_bad;
+
+    return lhs.extents() == rhs.extents() &&
+           lhs.form_factor() == rhs.form_factor() &&
+        lhs.orientation() == rhs.orientation() &&
+           lhs.pixel_format() == rhs.pixel_format() &&
+        lhs.physical_size_mm() == rhs.physical_size_mm() &&
+           lhs.scale() == rhs.scale() &&
+           lhs.type() == rhs.type();
+}

=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2016-07-21 14:21:51 +0000
+++ test/CMakeLists.txt	2016-07-22 11:21:29 +0000
@@ -8,6 +8,7 @@
 
 add_executable(miral-test
     mru_window_list.cpp
+    active_outputs.cpp
 )
 
 target_link_libraries(miral-test

=== added file 'test/active_outputs.cpp'
--- test/active_outputs.cpp	1970-01-01 00:00:00 +0000
+++ test/active_outputs.cpp	2016-07-22 11:21:29 +0000
@@ -0,0 +1,205 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "miral/active_outputs.h"
+#include "miral/output.h"
+
+#include <mir/shell/display_configuration_controller.h>
+
+#include <mir_test_framework/headless_test.h>
+
+#include <mir/test/doubles/fake_display.h>
+#include <mir/test/doubles/stub_display_configuration.h>
+#include <mir/test/fake_shared.h>
+#include <mir/test/signal.h>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mg = mir::graphics;
+namespace mt = mir::test;
+namespace mtd = mir::test::doubles;
+namespace mtf = mir_test_framework;
+
+using namespace miral;
+using namespace testing;
+
+namespace
+{
+struct MockActiveOutputsListener : ActiveOutputsListener
+{
+    MOCK_METHOD0(advise_begin, void());
+    MOCK_METHOD0(advise_end, void());
+
+    MOCK_METHOD1(advise_create_output, void(Output const&));
+    MOCK_METHOD2(advise_update_output, void(Output const&, Output const&));
+    MOCK_METHOD1(advise_delete_output, void(Output const&));
+};
+
+std::vector<Rectangle> const output_rects{
+    {{0,0}, {640,480}},
+    {{640,0}, {640,480}}
+};
+
+struct ActiveOutputs : mtf::HeadlessTest
+{
+    ActiveOutputs()
+    {
+        add_to_environment("MIR_SERVER_NO_FILE", "");
+    }
+
+    void SetUp() override
+    {
+        mtf::HeadlessTest::SetUp();
+        preset_display(mt::fake_shared(display));
+        active_outputs_monitor(server);
+        active_outputs_monitor.add_listener(&active_outputs_listener);
+    }
+
+    void TearDown() override
+    {
+        active_outputs_monitor.delete_listener(&active_outputs_listener);
+        mtf::HeadlessTest::TearDown();
+    }
+
+    mtd::FakeDisplay display{output_rects};
+    ActiveOutputsMonitor active_outputs_monitor;
+    NiceMock<MockActiveOutputsListener> active_outputs_listener;
+
+    void update_outputs(std::vector<Rectangle> const& displays)
+    {
+        mt::Signal signal;
+        EXPECT_CALL(active_outputs_listener, advise_end()).WillOnce(Invoke([&]{signal.raise(); }));
+
+        mtd::StubDisplayConfig changed_stub_display_config{displays};
+        display.emit_configuration_change_event(mt::fake_shared(changed_stub_display_config));
+
+        signal.wait_for(std::chrono::seconds(10));
+        ASSERT_TRUE(signal.raised());
+    }
+
+    void invert_outputs_in_base_configuration()
+    {
+        mt::Signal signal;
+        EXPECT_CALL(active_outputs_listener, advise_end()).WillOnce(Invoke([&]{signal.raise(); }));
+
+        auto configuration = server.the_display()->configuration();
+        configuration->for_each_output([](mg::UserDisplayConfigurationOutput& output)
+            {
+                output.orientation = mir_orientation_inverted;
+            });
+
+        server.the_display_configuration_controller()->set_base_configuration(std::move(configuration));
+
+        signal.wait_for(std::chrono::seconds(10));
+        ASSERT_TRUE(signal.raised());
+    }
+};
+
+struct RunServer
+{
+    RunServer(mtf::HeadlessTest* self) : self{self} { self->start_server(); }
+    ~RunServer() { self->stop_server(); }
+
+    mtf::HeadlessTest* const self;
+};
+}
+
+TEST_F(ActiveOutputs, on_startup_listener_is_advised)
+{
+    InSequence seq;
+    EXPECT_CALL(active_outputs_listener, advise_begin());
+    EXPECT_CALL(active_outputs_listener, advise_create_output(_)).Times(2);
+    RunServer runner{this};
+
+    Mock::VerifyAndClearExpectations(&active_outputs_listener); // before shutdown
+}
+
+TEST_F(ActiveOutputs, when_output_unplugged_listener_is_advised)
+{
+    RunServer runner{this};
+
+    InSequence seq;
+    EXPECT_CALL(active_outputs_listener, advise_begin());
+    EXPECT_CALL(active_outputs_listener, advise_delete_output(_)).Times(1);
+    update_outputs({{{0,0}, {640,480}}});
+
+    Mock::VerifyAndClearExpectations(&active_outputs_listener); // before shutdown
+}
+
+TEST_F(ActiveOutputs, when_output_added_listener_is_advised)
+{
+    RunServer runner{this};
+
+    auto new_output_rects = output_rects;
+    new_output_rects.emplace_back(Point{1280,0}, Size{640,480});
+
+    InSequence seq;
+    EXPECT_CALL(active_outputs_listener, advise_begin());
+    EXPECT_CALL(active_outputs_listener, advise_create_output(_)).Times(1);
+    update_outputs(new_output_rects);
+
+    Mock::VerifyAndClearExpectations(&active_outputs_listener); // before shutdown
+}
+
+TEST_F(ActiveOutputs, when_output_resized_listener_is_advised)
+{
+    RunServer runner{this};
+
+    auto new_output_rects = output_rects;
+    new_output_rects[1] = {Point{640,0}, Size{1080,768}};
+
+    InSequence seq;
+    EXPECT_CALL(active_outputs_listener, advise_begin());
+    EXPECT_CALL(active_outputs_listener, advise_update_output(_, _)).Times(1);
+    update_outputs(new_output_rects);
+
+    Mock::VerifyAndClearExpectations(&active_outputs_listener); // before shutdown
+}
+
+TEST_F(ActiveOutputs, when_base_configuration_is_updated_listener_is_advised)
+{
+    RunServer runner{this};
+
+    InSequence seq;
+    EXPECT_CALL(active_outputs_listener, advise_begin());
+    EXPECT_CALL(active_outputs_listener, advise_update_output(_, _)).Times(2);
+    invert_outputs_in_base_configuration();
+
+    Mock::VerifyAndClearExpectations(&active_outputs_listener); // before shutdown
+}
+
+TEST_F(ActiveOutputs, available_to_process)
+{
+    RunServer runner{this};
+
+    active_outputs_monitor.for_each_output([](std::vector<Output> const& outputs)
+        { EXPECT_THAT(outputs.size(), Eq(output_rects.size())); });
+}
+
+TEST_F(ActiveOutputs, updates_are_available_to_process)
+{
+    RunServer runner{this};
+
+    auto new_output_rects = output_rects;
+    new_output_rects.emplace_back(Point{1280,0}, Size{640,480});
+    update_outputs(new_output_rects);
+
+    active_outputs_monitor.for_each_output([&](std::vector<Output> const& outputs)
+        { EXPECT_THAT(outputs.size(), Eq(new_output_rects.size())); });
+}