Merge lp:~alan-griffiths/mir/test-without-ABI-bump-libmirserver into lp:mir

[Alan Griffiths]

*Test MP*

It looks as though bumping the mir server ABI breaks the maki when installed. This is just the other changes to see what happens.

*Test MP*

It looks as though bumping the mir server ABI breaks the maki when installed. This is just the other changes to see what happens.

[Alan Griffiths (alan-griffiths)]

Not intended to land

review: Disapprove

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2328
http://jenkins.qa.ubuntu.com/job/mir-ci/3008/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1343
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1342
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/1299
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1005
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1005/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1299
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/1299/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4331
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/18166

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

review: Approve (continuous-integration)

Unmerged revisions

2328. By Alan Griffiths on 2015-02-18

Not the libmirserver ABI bump

=== modified file 'include/server/mir/scene/surface_coordinator.h'
--- include/server/mir/scene/surface_coordinator.h	2015-01-21 07:34:50 +0000
+++ include/server/mir/scene/surface_coordinator.h	2015-02-18 17:45:38 +0000
@@ -24,6 +24,7 @@
 
 namespace mir
 {
+namespace geometry { class Point; }
 namespace scene
 {
 class Surface;
@@ -41,6 +42,9 @@
     virtual void raise(std::weak_ptr<Surface> const& surface) = 0;
 
     virtual void remove_surface(std::weak_ptr<Surface> const& surface) = 0;
+
+    virtual auto surface_at(geometry::Point) const -> std::shared_ptr<Surface> = 0;
+
 protected:
     SurfaceCoordinator() = default;
     virtual ~SurfaceCoordinator() = default;

=== modified file 'src/server/scene/surface_controller.cpp'
--- src/server/scene/surface_controller.cpp	2015-02-13 06:12:34 +0000
+++ src/server/scene/surface_controller.cpp	2015-02-18 17:45:38 +0000
@@ -49,3 +49,9 @@
 {
     surface_stack->raise(surface);
 }
+
+auto ms::SurfaceController::surface_at(geometry::Point cursor) const
+-> std::shared_ptr<Surface>
+{
+    return surface_stack->surface_at(cursor);
+}

=== modified file 'src/server/scene/surface_controller.h'
--- src/server/scene/surface_controller.h	2015-02-13 06:12:34 +0000
+++ src/server/scene/surface_controller.h	2015-02-18 17:45:38 +0000
@@ -46,6 +46,8 @@
 
     void raise(std::weak_ptr<Surface> const& surface) override;
 
+    auto surface_at(geometry::Point) const -> std::shared_ptr<Surface> override;
+
 private:
     std::shared_ptr<SurfaceFactory> const surface_factory;
     std::shared_ptr<SurfaceStackModel> const surface_stack;

=== modified file 'src/server/scene/surface_stack.cpp'
--- src/server/scene/surface_stack.cpp	2015-02-13 06:12:34 +0000
+++ src/server/scene/surface_stack.cpp	2015-02-18 17:45:38 +0000
@@ -277,6 +277,43 @@
     // TODO: error logging when surface not found
 }
 
+namespace
+{
+template <typename Container>
+struct InReverse {
+    Container& container;
+    auto begin() -> decltype(container.rbegin()) { return container.rbegin(); }
+    auto end() -> decltype(container.rend()) { return container.rend(); }
+};
+
+template <typename Container>
+InReverse<Container> in_reverse(Container& container) { return InReverse<Container>{container}; }
+}
+
+auto ms::SurfaceStack::surface_at(geometry::Point cursor) const
+-> std::shared_ptr<Surface>
+{
+    std::lock_guard<decltype(guard)> lg(guard);
+    for (auto &layer : in_reverse(layers_by_depth))
+    {
+        for (auto const& surface : in_reverse(layer.second))
+        {
+            // TODO this implementation is probably simplistic as the client area may,
+            // TODO in principle, have transparency. I don't think we have a mechanism
+            // TODO to track this yet.
+            // TODO Daniel has suggested using "surface->input_area_contains(cursor)"
+            // TODO here but has also (in the code that uses this) pointed out that
+            // TODO "the input area the client has designated is probably irrelevant.
+            // TODO Instead you want to consider the whole surface rectangle..."
+            if (surface->visible() &&
+                geom::Rectangle{surface->top_left(), surface->size()}.contains(cursor))
+                    return surface;
+        }
+    }
+
+    return {};
+}
+
 void ms::SurfaceStack::for_each(std::function<void(std::shared_ptr<mi::Surface> const&)> const& callback)
 {
     std::lock_guard<decltype(guard)> lg(guard);

=== modified file 'src/server/scene/surface_stack.h'
--- src/server/scene/surface_stack.h	2015-01-21 09:51:37 +0000
+++ src/server/scene/surface_stack.h	2015-02-18 17:45:38 +0000
@@ -89,6 +89,8 @@
         DepthId depth,
         input::InputReceptionMode input_mode) override;
     
+    auto surface_at(geometry::Point) const -> std::shared_ptr<Surface> override;
+
     void add_observer(std::shared_ptr<Observer> const& observer) override;
     void remove_observer(std::weak_ptr<Observer> const& observer) override;
     

=== modified file 'src/server/scene/surface_stack_model.h'
--- src/server/scene/surface_stack_model.h	2015-01-21 07:34:50 +0000
+++ src/server/scene/surface_stack_model.h	2015-02-18 17:45:38 +0000
@@ -27,6 +27,8 @@
 
 namespace mir
 {
+namespace geometry { class Point; }
+
 namespace scene
 {
 class Surface;
@@ -34,7 +36,7 @@
 class SurfaceStackModel
 {
 public:
-    virtual ~SurfaceStackModel() {}
+    virtual ~SurfaceStackModel() = default;
 
     virtual void add_surface(
         std::shared_ptr<Surface> const& surface,
@@ -45,6 +47,8 @@
 
     virtual void raise(std::weak_ptr<Surface> const& surface) = 0;
 
+    virtual auto surface_at(geometry::Point) const -> std::shared_ptr<Surface> = 0;
+
 protected:
     SurfaceStackModel() = default;
     SurfaceStackModel(const SurfaceStackModel&) = delete;

=== modified file 'tests/include/mir_test_doubles/mock_surface_coordinator.h'
--- tests/include/mir_test_doubles/mock_surface_coordinator.h	2015-02-13 06:12:34 +0000
+++ tests/include/mir_test_doubles/mock_surface_coordinator.h	2015-02-18 17:45:38 +0000
@@ -41,6 +41,7 @@
         scene::Session* session));
 
     MOCK_METHOD1(remove_surface, void(std::weak_ptr<scene::Surface> const& surface));
+    MOCK_CONST_METHOD1(surface_at, std::shared_ptr<scene::Surface>(geometry::Point));
 };
 
 }

=== modified file 'tests/unit-tests/scene/test_application_session.cpp'
--- tests/unit-tests/scene/test_application_session.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/scene/test_application_session.cpp	2015-02-18 17:45:38 +0000
@@ -97,6 +97,10 @@
     void remove_surface(std::weak_ptr<ms::Surface> const&) override
     {
     }
+    auto surface_at(mir::geometry::Point) const -> std::shared_ptr<ms::Surface>
+    {
+        return std::shared_ptr<ms::Surface>{};
+    }
 };
 
 struct ApplicationSession : public testing::Test

=== modified file 'tests/unit-tests/scene/test_surface_controller.cpp'
--- tests/unit-tests/scene/test_surface_controller.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/scene/test_surface_controller.cpp	2015-02-18 17:45:38 +0000
@@ -52,6 +52,7 @@
         mir::input::InputReceptionMode input_mode));
     MOCK_METHOD1(remove_surface, void(std::weak_ptr<ms::Surface> const&));
     MOCK_METHOD1(raise, void(std::weak_ptr<ms::Surface> const&));
+    MOCK_CONST_METHOD1(surface_at, std::shared_ptr<ms::Surface>(geom::Point));
 };
 
 struct SurfaceController : testing::Test

=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2015-02-13 06:12:34 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2015-02-18 17:45:38 +0000
@@ -882,3 +882,50 @@
     stack.for_each(count_exposed_surfaces);
     EXPECT_THAT(num_exposed_surfaces, Eq(1));
 }
+
+using namespace ::testing;
+
+TEST_F(SurfaceStack, returns_top_surface_under_cursor)
+{
+    geom::Point const cursor_over_all {100, 100};
+    geom::Point const cursor_over_12  {200, 100};
+    geom::Point const cursor_over_1   {600, 600};
+    geom::Point const cursor_over_none{999, 999};
+
+    stack.add_surface(stub_surface1, default_params.depth, default_params.input_mode);
+    stack.add_surface(stub_surface2, default_params.depth, default_params.input_mode);
+    stack.add_surface(stub_surface3, default_params.depth, default_params.input_mode);
+
+    stub_surface1->resize({900, 900});
+    stub_surface2->resize({500, 200});
+    stub_surface3->resize({200, 500});
+
+    EXPECT_THAT(stack.surface_at(cursor_over_all),  Eq(stub_surface3));
+    EXPECT_THAT(stack.surface_at(cursor_over_12),   Eq(stub_surface2));
+    EXPECT_THAT(stack.surface_at(cursor_over_1),    Eq(stub_surface1));
+    EXPECT_THAT(stack.surface_at(cursor_over_none).get(), IsNull());
+}
+
+TEST_F(SurfaceStack, returns_top_visible_surface_under_cursor)
+{
+    geom::Point const cursor_over_all {100, 100};
+    geom::Point const cursor_over_12  {200, 100};
+    geom::Point const cursor_over_1   {600, 600};
+    geom::Point const cursor_over_none{999, 999};
+
+    stack.add_surface(stub_surface1, default_params.depth, default_params.input_mode);
+    stack.add_surface(stub_surface2, default_params.depth, default_params.input_mode);
+    stack.add_surface(stub_surface3, default_params.depth, default_params.input_mode);
+    stack.add_surface(invisible_stub_surface, default_params.depth, default_params.input_mode);
+
+    stub_surface1->resize({900, 900});
+    stub_surface2->resize({500, 200});
+    stub_surface3->resize({200, 500});
+    invisible_stub_surface->resize({999, 999});
+
+    EXPECT_THAT(stack.surface_at(cursor_over_all),  Eq(stub_surface3));
+    EXPECT_THAT(stack.surface_at(cursor_over_12),   Eq(stub_surface2));
+    EXPECT_THAT(stack.surface_at(cursor_over_1),    Eq(stub_surface1));
+    EXPECT_THAT(stack.surface_at(cursor_over_none).get(), IsNull());
+}
+