Merge lp:~alan-griffiths/qtmir/test-harness-for-MirWindowManager into lp:qtmir

[Alan Griffiths]

Test harness for MirWindowManager (in preparation for more intelligent window management)

Test harness for MirWindowManager (in preparation for more intelligent window management)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:390
http://jenkins.qa.ubuntu.com/job/qtmir-ci/505/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/201
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/201
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/201/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/83
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/238
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/238
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/238/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/83

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/505/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

+// and there's not even a proper stub in the Mir-0.15 package mirtest-dev
how about mir 0.17, which will land before this will?

[Alan Griffiths (alan-griffiths)]

> +// and there's not even a proper stub in the Mir-0.15 package mirtest-dev
> how about mir 0.17, which will land before this will?

No, nothing much changed since then. But we can feedback to the Mir team. ;)

[Gerry Boland (gerboland)]

+struct AttribValuePair
+{
+ MirSurfaceAttrib attribute;
+ int value;
+ friend std::ostream& operator<<(std::ostream& out, AttribValuePair const& pair)
+ { return out << "attribute:" << pair.attribute << ", value:" << pair.value; }
+};

Qt has a QPair. STL has pair. This just for readability?

This is a decent foundation for what comes next.

[Alan Griffiths (alan-griffiths)]

> +struct AttribValuePair
...
> Qt has a QPair. STL has pair. This just for readability?

Yes.

    const auto attribute = GetParam().attribute;
    const auto value = GetParam().value;

is clearer than:

    const auto attribute = GetParam().first;
    const auto value = GetParam().second;

and the operator<<() injection here is cleaner than with "using AttribValuePair = std::pair<MirSurfaceAttrib, int>". C.f.

    namespace std
    {
    ostream& operator<<(ostream& out, AttribValuePair const& pair)
    { return out << "attribute:" << pair.first << ", value:" << pair.second; }
    }

[Alan Griffiths (alan-griffiths)]

> > +// and there's not even a proper stub in the Mir-0.15 package mirtest-dev
> > how about mir 0.17, which will land before this will?
>
> No, nothing much changed since then. But we can feedback to the Mir team. ;)

Vis: lp:~alan-griffiths/mir/dd-some-stubs-to-mirtest-dev/+merge/274262

[Gerry Boland (gerboland)]

LGTM

review: Approve

[Michał Sawicz (saviq)]

This stopped building, please the build output in:

http://s-jenkins.ubuntu-ci:8080/job/qtmir-vivid-i386-ci/111/console

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:391
http://jenkins.qa.ubuntu.com/job/qtmir-ci/533/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/229/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/229/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/111/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/266/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/266/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/111/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/533/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:392
http://jenkins.qa.ubuntu.com/job/qtmir-ci/534/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/230/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/230/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/112/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/267/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/267/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/112/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/534/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:393
http://jenkins.qa.ubuntu.com/job/qtmir-ci/535/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/231
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/231
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/231/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/113
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/268/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/268/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/113/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/535/rebuild

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

Let's get this in

review: Approve

[lp:~alan-griffiths/qtmir/test-harness-for-MirWindowManager]

399. By Michał Sawicz on 2015-11-02

Clean up packaging and fix autopkgtest on armhf
Approved by: Gerry Boland

400. By Michael Terry on 2015-11-02

Support new isTouchApp property to ApplicationInfoInterface and move lifecycle policy logic out of qtmir.

Now that qtmir won't decide policy for suspending anymore, we don't need all the lifecycleException handling in qtmir either. That can move to unity8.

But since the GSettings key for that was registered under the qtmir namespace (and there's no technical reason to migrate settings), I left the schema and classes dealing with GSettings alone, for future use.

401. By Nick Dedekind on 2015-11-02

Support server->client visibility change to stop rendering (lp:#1475678) Fixes: #1475678
Approved by: Daniel d'Andrada

402. By Alan Griffiths on 2015-11-02

Test harness for MirWindowManager (in preparation for more intelligent window management)
Approved by: Gerry Boland

=== modified file 'tests/mirserver/CMakeLists.txt'
--- tests/mirserver/CMakeLists.txt	2015-08-20 10:16:54 +0000
+++ tests/mirserver/CMakeLists.txt	2015-10-28 09:56:30 +0000
@@ -2,3 +2,4 @@
 add_subdirectory(Clipboard)
 add_subdirectory(Screen)
 add_subdirectory(ScreenController)
+add_subdirectory(WindowManager)

=== added directory 'tests/mirserver/WindowManager'
=== added file 'tests/mirserver/WindowManager/CMakeLists.txt'
--- tests/mirserver/WindowManager/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/mirserver/WindowManager/CMakeLists.txt	2015-10-28 09:56:30 +0000
@@ -0,0 +1,21 @@
+include_directories(
+  ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
+  ${MIRSERVER_INCLUDE_DIRS}
+)
+
+add_executable(WindowManagerTest
+  window_manager.cpp
+  stub_surface.cpp
+  stub_session.cpp
+)
+
+target_link_libraries(
+  WindowManagerTest
+
+  qpa-mirserver
+
+  ${GTEST_BOTH_LIBRARIES}
+  ${GMOCK_LIBRARIES}
+)
+
+add_test(WindowManager, WindowManagerTest)

=== added file 'tests/mirserver/WindowManager/stub_session.cpp'
--- tests/mirserver/WindowManager/stub_session.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/WindowManager/stub_session.cpp	2015-10-28 09:56:30 +0000
@@ -0,0 +1,125 @@
+/*
+ * 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "stub_session.h"
+
+std::shared_ptr<mir::frontend::Surface> StubSession::get_surface(
+    mir::frontend::SurfaceId /*surface*/) const
+{
+    return {};
+}
+
+std::string StubSession::name() const
+{
+    return {};
+}
+
+void StubSession::force_requests_to_complete()
+{
+}
+
+pid_t StubSession::process_id() const
+{
+    return {0};
+}
+
+void StubSession::take_snapshot(
+    mir::scene::SnapshotCallback const& /*snapshot_taken*/)
+{
+}
+
+std::shared_ptr<mir::scene::Surface> StubSession::default_surface() const
+{
+    return {};
+}
+
+void StubSession::set_lifecycle_state(MirLifecycleState /*state*/)
+{
+}
+
+void StubSession::send_display_config(
+    mir::graphics::DisplayConfiguration const& /*configuration*/)
+{
+}
+
+void StubSession::hide()
+{
+}
+
+void StubSession::show()
+{
+}
+
+void StubSession::start_prompt_session()
+{
+}
+
+void StubSession::stop_prompt_session()
+{
+}
+
+void StubSession::suspend_prompt_session()
+{
+}
+
+void StubSession::resume_prompt_session()
+{
+}
+
+mir::frontend::SurfaceId StubSession::create_surface(
+    mir::scene::SurfaceCreationParameters const& /*params*/,
+    std::shared_ptr<mir::frontend::EventSink> const& /*sink*/)
+{
+    return mir::frontend::SurfaceId{0};
+}
+
+void StubSession::destroy_surface(mir::frontend::SurfaceId /*surface*/)
+{
+}
+
+std::shared_ptr<mir::scene::Surface> StubSession::surface(
+    mir::frontend::SurfaceId /*surface*/) const
+{
+    return {};
+}
+
+std::shared_ptr<mir::scene::Surface> StubSession::surface_after(
+    std::shared_ptr<mir::scene::Surface> const& /*ptr*/) const
+{
+    return {};
+}
+
+std::shared_ptr<mir::frontend::BufferStream> StubSession::get_buffer_stream(
+    mir::frontend::BufferStreamId /*stream*/) const
+{
+    return {};
+}
+
+mir::frontend::BufferStreamId StubSession::create_buffer_stream(
+    mir::graphics::BufferProperties const& /*props*/)
+{
+    return {};
+}
+
+void StubSession::destroy_buffer_stream(mir::frontend::BufferStreamId /*stream*/)
+{
+}
+
+void StubSession::configure_streams(
+    mir::scene::Surface& /*surface*/,
+    std::vector<mir::shell::StreamSpecification> const& /*config*/)
+{
+}

=== added file 'tests/mirserver/WindowManager/stub_session.h'
--- tests/mirserver/WindowManager/stub_session.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/WindowManager/stub_session.h	2015-10-28 09:56:30 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef QPAMIRSERVER_STUBSESSION_H
+#define QPAMIRSERVER_STUBSESSION_H
+
+#include <mir/scene/session.h>
+
+struct StubSession : mir::scene::Session
+{
+    std::shared_ptr<mir::frontend::Surface> get_surface(mir::frontend::SurfaceId surface) const override;
+    std::string name() const override;
+
+    void force_requests_to_complete() override;
+    pid_t process_id() const override;
+
+    void take_snapshot(mir::scene::SnapshotCallback const& snapshot_taken) override;
+    std::shared_ptr<mir::scene::Surface> default_surface() const override;
+    void set_lifecycle_state(MirLifecycleState state) override;
+    void send_display_config(mir::graphics::DisplayConfiguration const&) override;
+
+    void hide() override;
+    void show() override;
+
+    void start_prompt_session() override;
+    void stop_prompt_session() override;
+    void suspend_prompt_session() override;
+    void resume_prompt_session() override;
+
+    mir::frontend::SurfaceId create_surface(
+        mir::scene::SurfaceCreationParameters const& params,
+        std::shared_ptr<mir::frontend::EventSink> const& sink) override;
+
+    void destroy_surface(mir::frontend::SurfaceId surface) override;
+
+    std::shared_ptr<mir::scene::Surface> surface(mir::frontend::SurfaceId surface) const override;
+    std::shared_ptr<mir::scene::Surface> surface_after(std::shared_ptr<mir::scene::Surface> const&) const override;
+
+    std::shared_ptr<mir::frontend::BufferStream> get_buffer_stream(mir::frontend::BufferStreamId stream) const override;
+
+    mir::frontend::BufferStreamId create_buffer_stream(mir::graphics::BufferProperties const& props) override;
+    void destroy_buffer_stream(mir::frontend::BufferStreamId stream) override;
+    void configure_streams(mir::scene::Surface& surface, std::vector<mir::shell::StreamSpecification> const& config) override;
+};
+
+#endif //QPAMIRSERVER_STUBSESSION_H

=== added file 'tests/mirserver/WindowManager/stub_surface.cpp'
--- tests/mirserver/WindowManager/stub_surface.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/WindowManager/stub_surface.cpp	2015-10-28 09:56:30 +0000
@@ -0,0 +1,198 @@
+/*
+ * 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "stub_surface.h"
+#include <mir_toolkit/common.h>
+//#include <mir/input/input_reception_mode.h>
+
+std::string StubSurface::name() const
+{
+    return {};
+}
+
+void StubSurface::move_to(mir::geometry::Point const& /*top_left*/)
+{
+}
+
+float StubSurface::alpha() const
+{
+    return 0;
+}
+
+mir::geometry::Size StubSurface::size() const
+{
+    return {};
+}
+
+mir::geometry::Size StubSurface::client_size() const
+{
+    return {};
+}
+
+std::shared_ptr <mir::frontend::BufferStream> StubSurface::primary_buffer_stream() const
+{
+    return {};
+}
+
+void StubSurface::set_streams(std::list<mir::scene::StreamInfo> const& /*streams*/)
+{
+}
+
+bool StubSurface::supports_input() const
+{
+    return false;
+}
+
+int StubSurface::client_input_fd() const
+{
+    return 0;
+}
+
+std::shared_ptr <mir::input::InputChannel> StubSurface::input_channel() const
+{
+    return {};
+}
+
+mir::input::InputReceptionMode StubSurface::reception_mode() const
+{
+    return mir::input::InputReceptionMode::normal;
+}
+
+void StubSurface::set_reception_mode(mir::input::InputReceptionMode /*mode*/)
+{
+}
+
+void StubSurface::set_input_region(std::vector<mir::geometry::Rectangle> const& /*input_rectangles*/)
+{
+}
+
+void StubSurface::resize(mir::geometry::Size const& /*size*/)
+{
+}
+
+mir::geometry::Point StubSurface::top_left() const
+{
+    return {};
+}
+
+mir::geometry::Rectangle StubSurface::input_bounds() const
+{
+    return {};
+}
+
+bool StubSurface::input_area_contains(mir::geometry::Point const& /*point*/) const
+{
+    return false;
+}
+
+void StubSurface::consume(MirEvent const& /*event*/)
+{
+}
+
+void StubSurface::set_alpha(float /*alpha*/)
+{
+}
+
+void StubSurface::set_orientation(MirOrientation /*orientation*/)
+{
+}
+
+void StubSurface::set_transformation(glm::mat4 const& /*mat4*/)
+{
+}
+
+bool StubSurface::visible() const
+{
+    return false;
+}
+
+mir::graphics::RenderableList StubSurface::generate_renderables(mir::compositor::CompositorID /*id*/) const
+{
+    return {};
+}
+
+int StubSurface::buffers_ready_for_compositor(void const* /*compositor_id*/) const
+{
+    return 0;
+}
+
+MirSurfaceType StubSurface::type() const
+{
+    return MirSurfaceType::mir_surface_type_normal;
+}
+
+MirSurfaceState StubSurface::state() const
+{
+    return MirSurfaceState::mir_surface_state_fullscreen;
+}
+
+int StubSurface::configure(MirSurfaceAttrib /*attrib*/, int value)
+{
+    return value;
+}
+
+int StubSurface::query(MirSurfaceAttrib /*attrib*/) const
+{
+    return 0;
+}
+
+void StubSurface::hide()
+{
+}
+
+void StubSurface::show()
+{
+}
+
+void StubSurface::set_cursor_image(std::shared_ptr<mir::graphics::CursorImage> const& /*image*/)
+{
+}
+
+std::shared_ptr<mir::graphics::CursorImage> StubSurface::cursor_image() const
+{
+    return {};
+}
+
+void StubSurface::set_cursor_stream(
+    std::shared_ptr<mir::frontend::BufferStream> const& /*stream*/,
+    mir::geometry::Displacement const& /*hotspot*/)
+{
+}
+
+void StubSurface::request_client_surface_close()
+{
+}
+
+std::shared_ptr<mir::scene::Surface> StubSurface::parent() const
+{
+    return {};
+}
+
+void StubSurface::add_observer(std::shared_ptr<mir::scene::SurfaceObserver> const& /*observer*/)
+{
+}
+
+void StubSurface::remove_observer(std::weak_ptr < mir::scene::SurfaceObserver > const& /*observer*/)
+{
+}
+
+void StubSurface::set_keymap(xkb_rule_names const& /*rules*/)
+{
+}
+
+void StubSurface::rename(std::string const& /*title*/)
+{
+}

=== added file 'tests/mirserver/WindowManager/stub_surface.h'
--- tests/mirserver/WindowManager/stub_surface.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/WindowManager/stub_surface.h	2015-10-28 09:56:30 +0000
@@ -0,0 +1,67 @@
+/*
+ * 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/>.
+ */
+
+#ifndef QPAMIRSERVER_STUB_SURFACE_H
+#define QPAMIRSERVER_STUB_SURFACE_H
+
+#include <mir/scene/surface.h>
+
+// mir::scene::Surface is a horribly wide interface to expose from Mir
+// and there's not even a proper stub in the Mir-0.15 package mirtest-dev
+struct StubSurface : mir::scene::Surface
+{
+    std::string name() const override;
+    void move_to(mir::geometry::Point const& top_left) override;
+    float alpha() const override;
+    mir::geometry::Size size() const override;
+    mir::geometry::Size client_size() const override;
+    std::shared_ptr<mir::frontend::BufferStream> primary_buffer_stream() const override;
+    void set_streams(std::list<mir::scene::StreamInfo> const& streams) override;
+    bool supports_input() const override;
+    int client_input_fd() const override;
+    std::shared_ptr<mir::input::InputChannel> input_channel() const override;
+    mir::input::InputReceptionMode reception_mode() const override;
+    void set_reception_mode(mir::input::InputReceptionMode mode) override;
+    void set_input_region(std::vector<mir::geometry::Rectangle> const& input_rectangles) override;
+    void resize(mir::geometry::Size const& size) override;
+    mir::geometry::Point top_left() const override;
+    mir::geometry::Rectangle input_bounds() const override;
+    bool input_area_contains(mir::geometry::Point const& point) const override;
+    void consume(MirEvent const& event) override;
+    void set_alpha(float alpha) override;
+    void set_orientation(MirOrientation orientation) override;
+    void set_transformation(glm::mat4 const&) override;
+    bool visible() const override;
+    mir::graphics::RenderableList generate_renderables(mir::compositor::CompositorID id) const override;
+    int buffers_ready_for_compositor(void const* compositor_id) const override;
+    MirSurfaceType type() const override;
+    MirSurfaceState state() const override;
+    int configure(MirSurfaceAttrib attrib, int value) override;
+    int query(MirSurfaceAttrib attrib) const override;
+    void hide() override;
+    void show() override;
+    void set_cursor_image(std::shared_ptr<mir::graphics::CursorImage> const& image) override;
+    std::shared_ptr<mir::graphics::CursorImage> cursor_image() const override;
+    void set_cursor_stream(std::shared_ptr<mir::frontend::BufferStream> const& stream, mir::geometry::Displacement const& hotspot) override;
+    void request_client_surface_close() override;
+    std::shared_ptr<Surface> parent() const override;
+    void add_observer(std::shared_ptr<mir::scene::SurfaceObserver> const& observer) override;
+    void remove_observer(std::weak_ptr<mir::scene::SurfaceObserver> const& observer) override;
+    void set_keymap(xkb_rule_names const& rules) override;
+    void rename(std::string const& title) override;
+};
+
+#endif //QPAMIRSERVER_STUB_SURFACE_H

=== added file 'tests/mirserver/WindowManager/window_manager.cpp'
--- tests/mirserver/WindowManager/window_manager.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/WindowManager/window_manager.cpp	2015-10-28 09:56:30 +0000
@@ -0,0 +1,324 @@
+/*
+ * Copyright (C) 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include "mirwindowmanager.h"
+#include "stub_surface.h"
+#include "stub_session.h"
+
+#include <mir/events/event_builders.h>
+#include <mir/scene/surface_creation_parameters.h>
+#include <mir/shell/display_layout.h>
+#include <mir/shell/focus_controller.h>
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+namespace mf = mir::frontend;
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+
+using namespace mir::geometry;
+using namespace testing;
+
+using mir::events::make_event;
+
+namespace
+{
+struct MockDisplayLayout : msh::DisplayLayout
+{
+    MOCK_METHOD1(clip_to_output, void (Rectangle& rect));
+    MOCK_METHOD1(size_to_output, void (Rectangle& rect));
+    MOCK_METHOD2(place_in_output, void (mir::graphics::DisplayConfigurationOutputId id, Rectangle& rect));
+};
+
+struct MockSurface : StubSurface
+{
+    MOCK_METHOD2(configure, int (MirSurfaceAttrib attrib, int value));
+};
+
+struct MockSession : StubSession
+{
+    MOCK_CONST_METHOD1(surface, std::shared_ptr<ms::Surface> (mir::frontend::SurfaceId surface));
+};
+
+struct StubFocusController : msh::FocusController
+{
+public:
+    void focus_next_session() override {}
+
+    std::shared_ptr<ms::Session> focused_session() const override { return {}; }
+
+    void set_focus_to(
+        std::shared_ptr<ms::Session> const& /*focus_session*/,
+        std::shared_ptr<ms::Surface> const& /*focus_surface*/) override {}
+
+    std::shared_ptr<ms::Surface> focused_surface() const override { return {}; }
+
+    std::shared_ptr<ms::Surface> surface_at(Point /*cursor*/) const override { return {}; }
+
+    void raise(msh::SurfaceSet const& /*surfaces*/) override {}
+};
+
+
+struct WindowManager : Test
+{
+    const std::shared_ptr<MockDisplayLayout> mock_display_layout =
+        std::make_shared<NiceMock<MockDisplayLayout>>();
+
+    StubFocusController focus_controller;
+
+    const std::unique_ptr<MirWindowManager> window_manager =
+        MirWindowManager::create(&focus_controller, mock_display_layout);
+
+    const Rectangle arbitrary_display{{0, 0}, {97, 101}};
+    const std::shared_ptr<MockSession> arbitrary_session = std::make_shared<NiceMock<MockSession>>();
+    const std::shared_ptr<ms::Surface> arbitrary_surface = std::make_shared<StubSurface>();
+    const ms::SurfaceCreationParameters arbitrary_params;
+    const mf::SurfaceId arbitrary_surface_id{__LINE__};
+
+    MOCK_METHOD2(build_surface, mf::SurfaceId(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params));
+
+    void SetUp() override
+    {
+        ON_CALL(*this, build_surface(_, _)).WillByDefault(Return(arbitrary_surface_id));
+        ON_CALL(*arbitrary_session, surface(_)).WillByDefault(Return(arbitrary_surface));
+
+        window_manager->add_session(arbitrary_session);
+    }
+
+    void TearDown() override
+    {
+        window_manager->remove_session(arbitrary_session);
+    }
+
+    void add_surface()
+    {
+        EXPECT_CALL(*this, build_surface(_, _));
+
+        window_manager->add_surface(
+            arbitrary_session,
+            arbitrary_params,
+            [this](std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)
+                {
+                    return build_surface(session, params);
+                });
+    }
+
+    static constexpr uint64_t arbitrary_mac = __LINE__;
+};
+}
+
+TEST_F(WindowManager, CreatesSurfaceUsingSuppliedBuilder)
+{
+    EXPECT_CALL(*this, build_surface(_, _));
+
+    const auto surface = window_manager->add_surface(
+        arbitrary_session,
+        arbitrary_params,
+        [this](std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)
+            {
+                return build_surface(session, params);
+            });
+
+    EXPECT_THAT(surface, Eq(arbitrary_surface_id));
+}
+
+TEST_F(WindowManager, SizesNewSurfaceToOutput)
+{
+    EXPECT_CALL(*this, build_surface(_, _)).Times(AnyNumber());
+
+    const Size request_size{0, 0};
+    const Size expect_size{57, 91};
+
+    ms::SurfaceCreationParameters params;
+    params.size = request_size;
+
+    EXPECT_CALL(*mock_display_layout, size_to_output(_)).
+        WillOnce(Invoke([&](Rectangle& rect)
+            {
+                EXPECT_THAT(rect.size, Eq(request_size));
+                rect.size = expect_size;
+            }));
+
+    add_surface();
+}
+
+namespace
+{
+struct AttribValuePair
+{
+    MirSurfaceAttrib attribute;
+    int value;
+    friend std::ostream& operator<<(std::ostream& out, AttribValuePair const& pair)
+    { return out << "attribute:" << pair.attribute << ", value:" << pair.value; }
+};
+struct SetAttribute : WindowManager, ::testing::WithParamInterface<AttribValuePair> {};
+}
+
+TEST_P(SetAttribute, ConfiguresSurface)
+{
+    const auto attribute = GetParam().attribute;
+    const auto value = GetParam().value;
+
+    const auto surface = std::make_shared<MockSurface>();
+
+    EXPECT_CALL(*arbitrary_session, surface(_)).Times(AnyNumber()).WillRepeatedly(Return(surface));
+    add_surface();
+
+    EXPECT_CALL(*surface, configure(attribute, value)).WillOnce(Return(value));
+
+    window_manager->set_surface_attribute(arbitrary_session, surface, attribute, value);
+}
+
+INSTANTIATE_TEST_CASE_P(WindowManager, SetAttribute,
+    Values(
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_restored},
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_minimized},
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_maximized},
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_vertmaximized},
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_fullscreen},
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_horizmaximized},
+        AttribValuePair{mir_surface_attrib_state, mir_surface_state_hidden},
+
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_normal},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_utility},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_dialog},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_overlay},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_freestyle},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_popover},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_inputmethod},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_satellite},
+        AttribValuePair{mir_surface_attrib_type, mir_surface_type_tip},
+
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_portrait},
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_landscape},
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_portrait_inverted},
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_landscape_inverted},
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_portrait_any},
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_landscape_any},
+        AttribValuePair{mir_surface_attrib_preferred_orientation, mir_orientation_mode_any}
+    ));
+
+// The following calls are /currently/ ignored, but we can check they don't "blow up"
+TEST_F(WindowManager, HandlesAddSession)
+{
+    EXPECT_NO_THROW(window_manager->add_session(arbitrary_session));
+}
+
+TEST_F(WindowManager, HandlesRemoveSession)
+{
+    EXPECT_NO_THROW(window_manager->remove_session(arbitrary_session));
+}
+
+TEST_F(WindowManager, HandlesAddDisplay)
+{
+    EXPECT_NO_THROW(window_manager->add_display(arbitrary_display));
+}
+
+TEST_F(WindowManager, HandlesRemoveDisplay)
+{
+    EXPECT_NO_THROW(window_manager->remove_display(arbitrary_display));
+}
+
+TEST_F(WindowManager, HandlesModifySurface)
+{
+    add_surface();
+
+    msh::SurfaceSpecification spec;
+
+    EXPECT_NO_THROW(
+        window_manager->modify_surface(arbitrary_session, arbitrary_surface, spec);
+    );
+
+    window_manager->remove_surface(arbitrary_session, arbitrary_surface);
+}
+
+TEST_F(WindowManager, HandlesKeyboardEvent)
+{
+    const MirInputDeviceId arbitrary_device{0};
+    const auto arbitrary_timestamp = std::chrono::steady_clock().now().time_since_epoch();
+    const auto arbitrary_action = mir_keyboard_action_down;
+    const xkb_keysym_t arbitrary_key_code{0};
+    const int arbitrary_scan_code = 0;
+    const MirInputEventModifiers arbitrary_event_modifiers{0};
+
+    const auto generic_event = make_event(
+        arbitrary_device,
+        arbitrary_timestamp,
+        arbitrary_mac,
+        arbitrary_action,
+        arbitrary_key_code,
+        arbitrary_scan_code,
+        arbitrary_event_modifiers);
+
+    const auto input_event = mir_event_get_input_event(generic_event.get());
+    const auto event = mir_input_event_get_keyboard_event(input_event);
+
+    EXPECT_NO_THROW(window_manager->handle_keyboard_event(event));
+}
+
+TEST_F(WindowManager, HandlesTouchEvent)
+{
+    const MirInputDeviceId arbitrary_device{0};
+    const auto arbitrary_timestamp = std::chrono::steady_clock().now().time_since_epoch();
+    const MirInputEventModifiers arbitrary_event_modifiers{0};
+
+    const auto generic_event = make_event(
+        arbitrary_device,
+        arbitrary_timestamp,
+        arbitrary_mac,
+        arbitrary_event_modifiers);
+
+    const auto input_event = mir_event_get_input_event(generic_event.get());
+    const auto event = mir_input_event_get_touch_event(input_event);
+
+    EXPECT_NO_THROW(window_manager->handle_touch_event(event));
+}
+
+TEST_F(WindowManager, HandlesPointerEvent)
+{
+    const MirInputDeviceId arbitrary_device{0};
+    const auto arbitrary_timestamp = std::chrono::steady_clock().now().time_since_epoch();
+    const MirInputEventModifiers arbitrary_event_modifiers{0};
+    const auto arbitrary_pointer_action = mir_pointer_action_button_down;
+    const auto arbitrary_pointer_buttons = mir_pointer_button_primary;
+    const float arbitrary_x_axis_value{0};
+    const float arbitrary_y_axis_value{0};
+    const float arbitrary_hscroll_value{0};
+    const float arbitrary_vscroll_value{0};
+    const float arbitrary_relative_x_value{0};
+    const float arbitrary_relative_y_value{0};
+
+    const auto generic_event = make_event(
+        arbitrary_device,
+        arbitrary_timestamp,
+        arbitrary_mac,
+        arbitrary_event_modifiers,
+        arbitrary_pointer_action,
+        arbitrary_pointer_buttons,
+        arbitrary_x_axis_value,
+        arbitrary_y_axis_value,
+        arbitrary_hscroll_value,
+        arbitrary_vscroll_value,
+        arbitrary_relative_x_value,
+        arbitrary_relative_y_value);
+
+    const auto input_event = mir_event_get_input_event(generic_event.get());
+    const auto event = mir_input_event_get_pointer_event(input_event);
+
+    EXPECT_NO_THROW(window_manager->handle_pointer_event(event));
+}