Merge lp:~vanvugt/mir/occlude into lp:mir

[Daniel van Vugt]

Avoid rendering surfaces that are fully hidden by other surfaces. This is
particularly important for mobile device performance. (LP: #1227739)

Technically the region searching algorithm used here is not proper region searching. We only look for rectangles fully enclosed by other rectangles. However what we have here is faster and simpler than arbitrary region calculations, and will still solve 99% of the important cases (touch apps). I also think it's a good thing to avoid complex region calculations for as long as possible.

Also note, for this to work, we need clients to create properly opaque surfaces using pixel format RGBX/XRGB etc. Any surface with an alpha channel will potentially be arbitrary in shape and translucency so cannot be considered as an occlusion.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1133
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/172/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/2371
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/2256
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/169
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/169/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-team-mir-development-branch-ci/172/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I just realized, this doesn't help Nexus 4. Mako only supports one pixel format: ABGR, meaning occlusion detection can never be used.

So to fix for N4 we need to do one of:
  (a) Introduce a dummy XBGR mode which is actually implemented as ABGR; or
  (b) Expose more pixel formats, because surely the hardware has a non-alpha mode; or
  (c) Remove the "shape" detection part of occlusion detection (though that's likely to completely break the current Unity8 shell); or
  (d) Implement an entirely new fix for bug 1227739 in Unity8 itself (?)

[Alexandros Frantzis (afrantzis)]

Nits:

183 +#include "glm/glm.hpp"

Not needed.

216 + * This is realible, but not ideal -- using the criteria address as a

Typo?

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

> So to fix for N4 we need to do one of:
> (a) Introduce a dummy XBGR mode which is actually implemented as ABGR; or
> (b) Expose more pixel formats, because surely the hardware has a non-alpha
> mode;

My vote goes to (b) if possible. It's useful to have non-alpha format in general, anyway.

[Daniel van Vugt (vanvugt)]

Nits fixed. Pretend I never mentioned Nexus 4. That's a separate problem for another day, which doesn't have to be solved here.

[Alexandros Frantzis (afrantzis)]

OK for now. Hopefully we will be able to handle occlusion more elegantly (i.e. no filter/match interplay) in our rework our scengraph/surfaces/model infrastructure.

> Pretend I never mentioned Nexus 4. That's a separate problem for another day, which doesn't have to be solved here.

I didn't expect it to :)

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1136
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/176/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/2384
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/2269
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/173
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/173/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-team-mir-development-branch-ci/176/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

But apart from merge conflicts seems reasonable

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

> But apart from merge conflicts seems reasonable

Actually, this probably doesn't need fixing as the jenkins bot doesn't see it.

review: Approve

[Kevin DuBois (kdub)]

lgtm

review: Approve

[Daniel van Vugt (vanvugt)]

That's weird. The conflict never showed up locally for me. But apparently gone now anyway.

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-autolanding/79/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/2403
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/2288
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-autolanding/78/console

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

The failure is unrelated to the proposal. See bug 1227683.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1137
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/189/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/2404
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/2289
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/186
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/186/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-team-mir-development-branch-ci/189/rebuild

review: Approve (continuous-integration)

=== modified file 'src/server/compositor/CMakeLists.txt'
--- src/server/compositor/CMakeLists.txt	2013-10-02 07:02:18 +0000
+++ src/server/compositor/CMakeLists.txt	2013-10-17 05:56:50 +0000
@@ -12,6 +12,7 @@
   multi_threaded_compositor.cpp
   switching_bundle.cpp
   bypass.cpp
+  occlusion.cpp
 )
 
 ADD_LIBRARY(

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2013-10-03 03:57:28 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2013-10-17 05:56:50 +0000
@@ -26,6 +26,7 @@
 #include "mir/graphics/buffer.h"
 #include "mir/surfaces/buffer_stream.h"
 #include "bypass.h"
+#include "occlusion.h"
 #include <mutex>
 #include <cstdlib>
 #include <vector>
@@ -38,16 +39,21 @@
 
 struct FilterForVisibleSceneInRegion : public mc::FilterForScene
 {
-    FilterForVisibleSceneInRegion(mir::geometry::Rectangle const& enclosing_region)
-        : enclosing_region(enclosing_region)
+    FilterForVisibleSceneInRegion(
+        mir::geometry::Rectangle const& enclosing_region,
+        mc::OcclusionMatch const& occlusions)
+        : enclosing_region(enclosing_region),
+          occlusions(occlusions)
     {
     }
     bool operator()(mc::CompositingCriteria const& info)
     {
-        return info.should_be_rendered_in(enclosing_region);
+        return info.should_be_rendered_in(enclosing_region) &&
+               !occlusions.occluded(info);
     }
 
     mir::geometry::Rectangle const& enclosing_region;
+    mc::OcclusionMatch const& occlusions;
 };
 
 std::mutex global_frameno_lock;
@@ -127,9 +133,14 @@
         display_buffer.make_current();
 
         auto const& view_area = display_buffer.view_area();
+
+        mc::OcclusionFilter occlusion_search(view_area);
+        mc::OcclusionMatch occlusion_match;
+        scene->reverse_for_each_if(occlusion_search, occlusion_match);
+
         renderer->clear(local_frameno);
         mc::RenderingOperator applicator(*renderer, save_resource);
-        FilterForVisibleSceneInRegion selector(view_area);
+        FilterForVisibleSceneInRegion selector(view_area, occlusion_match);
         scene->for_each_if(selector, applicator);
         overlay_renderer->render(view_area, save_resource);
 

=== added file 'src/server/compositor/occlusion.cpp'
--- src/server/compositor/occlusion.cpp	1970-01-01 00:00:00 +0000
+++ src/server/compositor/occlusion.cpp	2013-10-17 05:56:50 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#include "mir/compositor/compositing_criteria.h"
+#include "mir/geometry/rectangle.h"
+#include "occlusion.h"
+
+using namespace mir;
+using namespace mir::compositor;
+
+OcclusionFilter::OcclusionFilter(const geometry::Rectangle &area)
+        : area(area)
+{
+}
+
+bool OcclusionFilter::operator()(const CompositingCriteria &criteria)
+{
+    const glm::mat4 &trans = criteria.transformation();
+    bool orthogonal =
+        trans[0][1] == 0.0f &&
+        trans[0][2] == 0.0f &&
+        trans[0][3] == 0.0f &&
+        trans[1][0] == 0.0f &&
+        trans[1][2] == 0.0f &&
+        trans[1][3] == 0.0f &&
+        trans[2][0] == 0.0f &&
+        trans[2][1] == 0.0f &&
+        trans[2][2] == 0.0f &&
+        trans[2][3] == 0.0f &&
+        trans[3][2] == 0.0f &&
+        trans[3][3] == 1.0f;
+
+    if (!orthogonal)
+        return false;  // Weirdly transformed. Assume never occluded.
+
+    // This could be replaced by adding a "CompositingCriteria::rect()"
+    int width = trans[0][0];
+    int height = trans[1][1];
+    int x = trans[3][0] - width / 2;
+    int y = trans[3][1] - height / 2;
+    geometry::Rectangle window{{x, y}, {width, height}};
+
+    if (!criteria.should_be_rendered_in(area))
+        return true;  // Not on the display, or invisible; definitely occluded.
+
+    bool occluded = false;
+    for (const auto &r : coverage)
+    {
+        if (r.contains(window))
+        {
+            occluded = true;
+            break;
+        }
+    }
+
+    if (!occluded && criteria.alpha() == 1.0f && !criteria.shaped())
+        coverage.push_back(window);
+
+    return occluded;
+}
+
+void OcclusionMatch::operator()(const CompositingCriteria &criteria,
+                                surfaces::BufferStream &)
+{
+    hidden.insert(&criteria);
+}
+
+bool OcclusionMatch::occluded(const CompositingCriteria &criteria) const
+{
+    return hidden.find(&criteria) != hidden.end();
+}

=== added file 'src/server/compositor/occlusion.h'
--- src/server/compositor/occlusion.h	1970-01-01 00:00:00 +0000
+++ src/server/compositor/occlusion.h	2013-10-17 05:56:50 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_OCCLUSION_H_
+#define MIR_COMPOSITOR_OCCLUSION_H_
+
+#include "mir/compositor/scene.h"
+#include <vector>
+#include <set>
+
+namespace mir
+{
+namespace compositor
+{
+class CompositingCriteria;
+
+class OcclusionFilter : public FilterForScene
+{
+public:
+    OcclusionFilter(const geometry::Rectangle &area);
+    bool operator()(const CompositingCriteria &criteria) override;
+
+private:
+    const geometry::Rectangle &area;
+
+    typedef std::vector<geometry::Rectangle> RectangleList;
+    RectangleList coverage;
+};
+
+class OcclusionMatch : public OperatorForScene
+{
+public:
+    void operator()(const CompositingCriteria &,
+                    surfaces::BufferStream &stream) override;
+
+    bool occluded(const CompositingCriteria &criteria) const;
+
+private:
+    typedef std::set<const CompositingCriteria*> RenderableSet;
+    RenderableSet hidden;
+};
+
+} // namespace compositor
+} // namespace mir
+
+#endif // MIR_COMPOSITOR_OCCLUSION_H_

=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
--- tests/unit-tests/compositor/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ tests/unit-tests/compositor/CMakeLists.txt	2013-10-17 05:56:50 +0000
@@ -7,6 +7,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_switching_bundle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gl_renderer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_bypass.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_occlusion.cpp
 )
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== modified file 'tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp'
--- tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-10-16 07:57:33 +0000
+++ tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-10-17 05:56:50 +0000
@@ -78,7 +78,16 @@
         }
     }
 
-    void reverse_for_each_if(mc::FilterForScene&, mc::OperatorForScene&) {}
+    void reverse_for_each_if(mc::FilterForScene &filter,
+                             mc::OperatorForScene &op)
+    {
+        for (auto it = surfaces.rbegin(); it != surfaces.rend(); ++it)
+        {
+            mc::CompositingCriteria &criteria = **it;
+            if (filter(criteria))
+                op(criteria, stub_stream);
+        }
+    }
 
     void set_change_callback(std::function<void()> const&) {}
 
@@ -153,6 +162,9 @@
     EXPECT_CALL(scene, for_each_if(_,_))
                 .Times(1);
 
+    EXPECT_CALL(scene, reverse_for_each_if(_,_))
+        .Times(1);
+
     mc::DefaultDisplayBufferCompositorFactory factory(
         mt::fake_shared(scene),
         mt::fake_shared(renderer_factory),
@@ -197,9 +209,20 @@
 
     NiceMock<mtd::MockCompositingCriteria> mock_criteria1, mock_criteria2, mock_criteria3;
 
-    EXPECT_CALL(mock_criteria1, should_be_rendered_in(_)).WillOnce(Return(true));
-    EXPECT_CALL(mock_criteria2, should_be_rendered_in(_)).WillOnce(Return(false));
-    EXPECT_CALL(mock_criteria3, should_be_rendered_in(_)).WillOnce(Return(true));
+    glm::mat4 simple;
+    EXPECT_CALL(mock_criteria1, transformation())
+        .WillOnce(ReturnRef(simple));
+    EXPECT_CALL(mock_criteria2, transformation())
+        .WillOnce(ReturnRef(simple));
+    EXPECT_CALL(mock_criteria3, transformation())
+        .WillOnce(ReturnRef(simple));
+
+    EXPECT_CALL(mock_criteria1, should_be_rendered_in(_))
+        .WillOnce(Return(true));
+    EXPECT_CALL(mock_criteria2, should_be_rendered_in(_))
+        .WillOnce(Return(false));
+    EXPECT_CALL(mock_criteria3, should_be_rendered_in(_))
+        .WillOnce(Return(true));
 
     std::vector<mc::CompositingCriteria*> renderable_vec;
     renderable_vec.push_back(&mock_criteria1);
@@ -347,7 +370,7 @@
     renderable_vec.push_back(&fullscreen);
 
     EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
-        .Times(1);
+        .Times(0);  // zero due to occlusion detection
     EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
         .Times(1);
 
@@ -396,7 +419,7 @@
     renderable_vec.push_back(&fullscreen);
 
     EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
-        .Times(1);
+        .Times(0);  // zero due to occlusion detection
     EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
         .Times(1);
 
@@ -505,3 +528,47 @@
     comp->composite();
 }
 
+TEST(DefaultDisplayBufferCompositor, occluded_surface_is_never_rendered)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+    NiceMock<MockOverlayRenderer> overlay_renderer;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, make_current())
+        .Times(1);
+    EXPECT_CALL(display_buffer, post_update())
+        .Times(1);
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(false));
+
+    mtd::StubCompositingCriteria large(0, 0, 100, 100);
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&small);
+    renderable_vec.push_back(&large);
+
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
+        .Times(0);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(large),_))
+        .Times(1);
+
+    FakeScene scene(renderable_vec);
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory),
+        mt::fake_shared(overlay_renderer));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    comp->composite();
+}
+
+

=== added file 'tests/unit-tests/compositor/test_occlusion.cpp'
--- tests/unit-tests/compositor/test_occlusion.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/compositor/test_occlusion.cpp	2013-10-17 05:56:50 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#include "mir/compositor/compositing_criteria.h"
+#include "mir/geometry/rectangle.h"
+#include "src/server/compositor/occlusion.h"
+#include "mir_test_doubles/stub_buffer_stream.h"
+#include "mir_test_doubles/stub_compositing_criteria.h"
+
+#include <gtest/gtest.h>
+#include <memory>
+
+using namespace testing;
+using namespace mir::geometry;
+using namespace mir::compositor;
+using namespace mir::test::doubles;
+
+struct OcclusionFilterTest : public Test
+{
+    OcclusionFilterTest()
+    {
+        monitor_rect.top_left = {0, 0};
+        monitor_rect.size = {1920, 1200};
+    }
+
+    Rectangle monitor_rect;
+};
+
+TEST_F(OcclusionFilterTest, single_window_not_occluded)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria win(12, 34, 56, 78);
+
+    EXPECT_FALSE(filter(win));
+}
+
+TEST_F(OcclusionFilterTest, smaller_window_occluded)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10);
+    EXPECT_FALSE(filter(front));
+
+    StubCompositingCriteria back(12, 12, 5, 5);
+    EXPECT_TRUE(filter(back));
+}
+
+TEST_F(OcclusionFilterTest, translucent_window_occludes_nothing)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10, 0.5f);
+    EXPECT_FALSE(filter(front));
+
+    StubCompositingCriteria back(12, 12, 5, 5, 1.0f);
+    EXPECT_FALSE(filter(back));
+}
+
+TEST_F(OcclusionFilterTest, hidden_window_is_self_occluded)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10, 1.0f, true, false);
+    EXPECT_TRUE(filter(front));
+}
+
+TEST_F(OcclusionFilterTest, hidden_window_occludes_nothing)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10, 1.0f, true, false);
+    EXPECT_TRUE(filter(front));
+
+    StubCompositingCriteria back(12, 12, 5, 5);
+    EXPECT_FALSE(filter(back));
+}
+
+TEST_F(OcclusionFilterTest, shaped_window_occludes_nothing)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10, 1.0f, false, true);
+    EXPECT_FALSE(filter(front));
+
+    StubCompositingCriteria back(12, 12, 5, 5);
+    EXPECT_FALSE(filter(back));
+}
+
+TEST_F(OcclusionFilterTest, identical_window_occluded)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10);
+    EXPECT_FALSE(filter(front));
+
+    StubCompositingCriteria back(10, 10, 10, 10);
+    EXPECT_TRUE(filter(back));
+}
+
+TEST_F(OcclusionFilterTest, larger_window_never_occluded)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 10, 10, 10);
+    EXPECT_FALSE(filter(front));
+
+    StubCompositingCriteria back(9, 9, 12, 12);
+    EXPECT_FALSE(filter(back));
+}
+
+TEST_F(OcclusionFilterTest, cascaded_windows_never_occluded)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    for (int x = 0; x < 10; x++)
+    {
+        StubCompositingCriteria win(x, x, 200, 100);
+        ASSERT_FALSE(filter(win));
+    }
+}
+
+TEST_F(OcclusionFilterTest, some_occluded_and_some_not)
+{
+    OcclusionFilter filter(monitor_rect);
+
+    StubCompositingCriteria front(10, 20, 400, 300);
+    EXPECT_FALSE(filter(front));
+
+    EXPECT_TRUE(filter(StubCompositingCriteria(10, 20, 5, 5)));
+    EXPECT_TRUE(filter(StubCompositingCriteria(100, 100, 20, 20)));
+    EXPECT_TRUE(filter(StubCompositingCriteria(200, 200, 50, 50)));
+
+    EXPECT_FALSE(filter(StubCompositingCriteria(500, 600, 34, 56)));
+    EXPECT_FALSE(filter(StubCompositingCriteria(200, 200, 1000, 1000)));
+}
+
+TEST(OcclusionMatchTest, remembers_matches)
+{
+    OcclusionMatch match;
+    StubCompositingCriteria win(1, 2, 3, 4);
+    StubBufferStream bufs;
+
+    EXPECT_FALSE(match.occluded(win));
+    match(win, bufs);
+    EXPECT_TRUE(match.occluded(win));
+}
+