Mir

include/client/mir_toolkit/mir_cursor_configuration.h (+2/-11)
include/server/mir/input/input_targets.h (+8/-0)
include/server/mir/input/surface.h (+11/-0)
include/server/mir/scene/surface.h (+1/-1)
include/shared/mir_toolkit/common.h (+11/-0)
include/test/mir_test_doubles/mock_input_surface.h (+1/-14)
include/test/mir_test_doubles/stub_input_surface.h (+2/-0)
include/test/mir_test_doubles/stub_input_targets.h (+6/-0)
include/test/mir_test_doubles/stub_scene_surface.h (+1/-1)
include/test/mir_test_framework/stubbed_server_configuration.h (+2/-0)
src/client/cursor_configuration.h (+2/-0)
src/client/mir_cursor_api.cpp (+8/-5)
src/client/mir_surface.cpp (+1/-1)
src/server/default_server_configuration.cpp (+0/-24)
src/server/graphics/default_configuration.cpp (+3/-1)
src/server/input/CMakeLists.txt (+1/-0)
src/server/input/cursor_controller.cpp (+244/-0)
src/server/input/cursor_controller.h (+77/-0)
src/server/input/default_configuration.cpp (+11/-0)
src/server/scene/basic_surface.cpp (+5/-2)
src/server/scene/basic_surface.h (+1/-1)
tests/acceptance-tests/test_client_cursor_api.cpp (+357/-350)
tests/mir_test_framework/input_testing_server_options.cpp (+1/-3)
tests/mir_test_framework/stubbed_server_configuration.cpp (+15/-1)
tests/unit-tests/input/CMakeLists.txt (+1/-0)
tests/unit-tests/input/android/test_android_input_target_enumerator.cpp (+9/-0)
tests/unit-tests/input/test_cursor_controller.cpp (+391/-0)

To merge this branch:

bzr merge lp:~mir-team/mir/cursor-spike-phase-4-implement-api

Medium

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration	2014-05-19	Approve on 2014-06-23
Andreas Pokorny (community)			Approve on 2014-06-23
Alan Griffiths			Approve on 2014-06-23
Kevin DuBois (community)			Approve on 2014-06-16
Alberto Aguirre		2014-05-19	Pending
Review via email: mp+220108@code.launchpad.net

Commit message

Enable client cursor API.

Description of the change

Enable the cursor API.

Remaining phases:
5 - XCursor loader
6 - Demo client

Diff will shrink once
https://code.launchpad.net/~mir-team/mir/cursor-spike-lightning-round-fix-input-area-contains/+merge/220102

lands

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-05-19:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1671/rebuild

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-05-19:

looks good overall, just nits really:

361, 423-425
could be private

416/417 indentation

CursorController seems more like a CursorState. It listens for events and changes the state accordingly.

we could get rid of returning nullptr in topmost_surface_containing_point() (and the variable top_surface_at_point would still make the algorithm quickly comprehendable at first glance)

review: Needs Fixing

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2014-06-03:

A few nits, and I think some left-overs that you do not need -> Needs Fixing.
There are some Information Needed questions inside the inline comments.

review: Needs Fixing

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-03:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1805/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-04:

Start 21: mir_acceptance_tests.TestClientCursorAPI.*
Build timed out (after 120 minutes). Marking the build as failed.

I concur - this test hangs.

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-04:

Things now not present:

anpoks nits
deadlock (removed lock scope {} in a merge error)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-05:

FAILED: Continuous integration, rev:1539
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1826/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/469/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/470/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/468/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/345/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/344/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1324/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1826/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-09:

Fixed conflicts

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-09:

FAILED: Continuous integration, rev:1540
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1843/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/494
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/495
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/493/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/364
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/364/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/361
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/361/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1427
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1427/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1700/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/8252

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1843/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-10:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1847/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-10:

299 +struct SurfaceObserver : ms::SurfaceObserver

"SurfaceObserver" is a bad name - it doesn't indicate why the class exists. "UpdateCursorOnSurfaceChanges"?

~~~~

301 + SurfaceObserver(std::function<void()> const& update_cursor)

I don't see the advantage of "std::function<void()> const& update_cursor" over CursorController* - this class is buried in an implementation file so there is only abstraction cost here.

~~~~

436 + auto strong_observer = std::make_shared<Observer>([&]()
437 + {
438 + std::lock_guard<std::mutex> lg(cursor_state_guard);
439 + update_cursor_image_locked(lg);
440 + });

I'd prefer to see a lambda that didn't manipulate internal state; Vis

auto strong_observer = std::make_shared<Observer>([&]{ update_cursor_image(); });

But, given the above comments, we probably don't need a lambda at all. Just:

auto strong_observer = std::make_shared<UpdateCursorOnSceneChanges>(this);

~~~~

20 + virtual void add_observer(std::shared_ptr<scene::Observer> const& observer) = 0;
21 + virtual void remove_observer(std::weak_ptr<scene::Observer> const& observer) = 0;

It is unintuitive (to say the least) that scene::Observer observes input::InputTargets. (Yes, I know that these functions are implemented in scene::SurfaceStack - so this is probably best left until we get to cleaning up that part of scene.)

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-11:

Alan: Addressed your suggestions.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1864/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1867/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-12:

FAILED: Continuous integration, rev:1546
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1877/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/535
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/540/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/534
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/398
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/398/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/395
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/395/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1532
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1532/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1739
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/8362

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1877/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1878/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-13:

Failure looks spurious. Rebuilding

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-13:

Broken chroot tarball. Rebuilding.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1885/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1888/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1895/rebuild

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-06-14:

could be private:
405 + mi::CursorController* const cursor_controller;
406 +
407 + std::mutex surface_observers_guard;
408 + std::map<ms::Surface*, std::weak_ptr<ms::SurfaceObserver>> surface_observers;

should guard against exceptions:
441 +mi::CursorController::~CursorController()
442 +{
443 + input_targets->remove_observer(observer);
444 +}

needed?
484 + assert(input_targets);

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-16:

152 char const *const mir_default_cursor_name = "default";
237 + return the_cursor_images()->image("default", default_cursor_size);
1575 +std::string const default_cursor_name = "default";

I assume these string constants all need to be the same. Can't we use a single constant?

~~~~

164 + std::unique_ptr<MirCursorConfiguration> c(new MirCursorConfiguration);
165 + c->name = name ? std::string(name) : std::string();
166
167 - return c;
168 + return c.release();

Wouldn't a constructor that took a char* be a cleaner way to initialize the c?

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-16:

kdub:

>> could be private:
Now private!

>> should guard against exceptions:
Good catch!

>> needed?
>> 484 + assert(input_targets);
Nah, left over from an earlier version which had two phase initialization.

Alan:
>> I assume these string constants all need to be the same. Can't we use a single constant?

Consolidated!
~~~~
>> Wouldn't a constructor that took a char* be a cleaner way to initialize the c?

Handling it this way now.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-16:

A lot of nits:

222 +MirCursorConfiguration::MirCursorConfiguration(char const* s_name)
223 +{
224 + s_name ? name = std::string(s_name) : name = std::string();
225 +}

MirCursorConfiguration::MirCursorConfiguration(char const* name) :
name{name ? std::string(s_name) : std::string()}
{
}

~~~~

235 + std::unique_ptr<MirCursorConfiguration> c(new MirCursorConfiguration(name));
236
237 - return c;
238 + return c.release();

return new MirCursorConfiguration(name);

~~~~

263 +

Why?

~~~~

434 + auto observer = std::make_shared<UpdateCursorOnSurfaceChanges>(cursor_controller);

auto const?

~~~~

494 + std::shared_ptr<mi::Surface> top_surface_at_point = nullptr;

std::shared_ptr<mi::Surface> top_surface_at_point;

~~~~

523 + try
524 + {
525 + input_targets->remove_observer(observer);
526 + }
527 + catch (...)
528 + {
529 + }

I don't expect input_targets->remove_observer(observer) to throw.

If removing observer does throw then surely things are so broken that we should stop execution. Not eat the exception!

~~~~

730 #include "mir_test_framework/display_server_test_fixture.h"

Unused. (I suspect a whole bunch more includes are unused - e.g. #include "mir/compositor/scene.h")

~~~~

1017 +struct DeferredInProcessServer : mtf::InProcessServer
1018 +{
1019 + void SetUp() override { /* TODO this is a nasty frig around the unfortunate coupling in InProcessServer */ }
1020 + void start_server() { mtf::InProcessServer::SetUp(); }
1021 +};

You might like to update to match test_client_input.cpp (or even put somewhere common).

struct DeferredInProcessServer : testing::Test, private mtf::ServerRunner
{
void TearDown() override { ServerRunner::stop_server(); }

using ServerRunner::start_server;
using ServerRunner::new_connection;
};

~~~~

2001 + StubInputSurface surface1{geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
2002 + geom::Size{geom::Width{1}, geom::Height{1}}},
2003 + image};
2004 + StubInputSurface surface2{geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
2005 + geom::Size{geom::Width{1}, geom::Height{1}}},
2006 + image};

Alignment is wrong. (That's why I don't like aligning to the open brace.)

Also, I'm pretty sure most of those explicit constructions are unnecessary.

A lot of nits:

222	+MirCursorConfiguration::MirCursorConfiguration(char const* s_name)
223	+{
224	+ s_name ? name = std::string(s_name) : name = std::string();
225	+}

MirCursorConfiguration::MirCursorConfiguration(char const* name) :
    name{name ? std::string(s_name) : std::string()}
{
}

~~~~

235	+ std::unique_ptr<MirCursorConfiguration> c(new MirCursorConfiguration(name));
236	
237	- return c;
238	+ return c.release();

return new MirCursorConfiguration(name);

~~~~

263	+

Why?

~~~~

434	+ auto observer = std::make_shared<UpdateCursorOnSurfaceChanges>(cursor_controller);

auto const?

~~~~

494	+ std::shared_ptr<mi::Surface> top_surface_at_point = nullptr;

std::shared_ptr<mi::Surface> top_surface_at_point;

~~~~

523	+ try
524	+ {
525	+ input_targets->remove_observer(observer);
526	+ }
527	+ catch (...)
528	+ {
529	+ }

I don't expect input_targets->remove_observer(observer) to throw.

If removing observer does throw then surely things are so broken that we should stop execution. Not eat the exception!

~~~~

730	#include "mir_test_framework/display_server_test_fixture.h"

Unused. (I suspect a whole bunch more includes are unused - e.g. #include "mir/compositor/scene.h")

~~~~

1017	+struct DeferredInProcessServer : mtf::InProcessServer
1018	+{
1019	+ void SetUp() override { /* TODO this is a nasty frig around the unfortunate coupling in InProcessServer */ }
1020	+ void start_server() { mtf::InProcessServer::SetUp(); }
1021	+};

You might like to update to match test_client_input.cpp (or even put somewhere common).

struct DeferredInProcessServer : testing::Test, private mtf::ServerRunner
{
    void TearDown() override { ServerRunner::stop_server(); }

using ServerRunner::start_server;
    using ServerRunner::new_connection;
};

~~~~

2001	+ StubInputSurface surface1{geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
2002	+ geom::Size{geom::Width{1}, geom::Height{1}}},
2003	+ image};
2004	+ StubInputSurface surface2{geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
2005	+ geom::Size{geom::Width{1}, geom::Height{1}}},
2006	+ image};

Alignment is wrong. (That's why I don't like aligning to the open brace.)

Also, I'm pretty sure most of those explicit constructions are unnecessary.

review: Needs Fixing

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-16:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1911/rebuild

review: Approve (continuous-integration)

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-16:

Nits addressed. updated to look like test client input.

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-06-16:

okay, once the nitfixes suggested by Alan are pushed

review: Approve

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-17:

Pushed! somehow my SSH password saver is just totally broken.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-17:

FAILED: Continuous integration, rev:1552
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1919/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/591/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/597/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/590/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/440/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/437/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1707/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1919/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-18:

> FAILED: Continuous integration, rev:1552
> http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1919/
> Executed test runs:
> FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-
> utopic-i386-build/591/console
> FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-
> amd64-build/597/console
> FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-
> touch/590/console
> FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-
> utopic-amd64-ci/440/console
> FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-
> utopic-armhf-ci/437/console
> FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-
> utopic-armhf/1707/console
>
> Click here to trigger a rebuild:
> http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-
> ci/1919/rebuild

bzr: ERROR: Conflicts from merge

review: Needs Fixing

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-19:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1938/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-20:

203 - * along with this program. If not, see <http://www.gnu.org/licenses/>.
204 +o * along with this program. If not, see <http://www.gnu.org/licenses/>.

review: Needs Fixing

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-20:

1912 + StubInputSurface surface{geom::Rectangle{geom::Point{geom::X{1}, geom::Y{1}},
1913 + geom::Size{geom::Width{1}, geom::Height{1}}},
1914 + nullptr};

There's a lot of verbose stuff repeated in the test bodies that could be shifted to the fixture. (Making the tests easier to read.)

E.g.

static geom::Rectangle const rect_1_1_1_1{{1, 1}, {1, 1}};
StubInputSurface surface_1_1_1_1{rect_1_1_1_1, nullptr};

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-20:

Thanks alan. Fixed stray o. Made the tests a bit easier to read...factored out some strings in addition to the rects.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-20:

FAILED: Continuous integration, rev:1556
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1952/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/638/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/644/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/638/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/473/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/470/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/1888/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1952/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-23:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1955/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-06-23:

review: Approve

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2014-06-23:

Ok - I still do not like that extra book keeping of surfaces and observers to surfaces are necessary necessary. But that is something to address later.

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) on 2014-06-23:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'include/client/mir_toolkit/mir_cursor_configuration.h'
 --- include/client/mir_toolkit/mir_cursor_configuration.h	2014-05-14 16:50:03 +0000
 +++ include/client/mir_toolkit/mir_cursor_configuration.h	2014-06-23 02:58:32 +0000
@@ -18,6 +18,8 @@
  #ifndef MIR_TOOLKIT_MIR_CURSOR_H_
  #define MIR_TOOLKIT_MIR_CURSOR_H_
++#include <mir_toolkit/common.h>
++
  /**
   * Opaque structure containing cursor parameterization. Create with mir_cursor* family.
   * Used with mir_surface_configure_cursor.
@@ -33,17 +35,6 @@
  #endif
  /**
-- * A special cursor name for use with mir_cursor_configuration_from_name
-- * representing the system default cursor.
-- */
--extern char const *const mir_default_cursor_name;
--/**
-- * A special cursor name for use with mir_cursor_configuration_from_name
-- * representing a disabled cursor image.
-- */
--extern char const *const mir_disabled_cursor_name;
--
--/**
   * Release resources assosciated with cursor parameters
   *     \param [in] parameters The operand
   */
 === modified file 'include/server/mir/input/input_targets.h'
 --- include/server/mir/input/input_targets.h	2014-04-24 08:42:12 +0000
 +++ include/server/mir/input/input_targets.h	2014-06-23 02:58:32 +0000
@@ -26,6 +26,11 @@
  namespace mir
+ {
++namespace scene
++{
++class Observer;
++}
++
  namespace input
+ {
  class Surface;
@@ -37,6 +42,9 @@
      virtual void for_each(std::function<void(std::shared_ptr<input::Surface> const&)> const& callback) = 0;
++    virtual void add_observer(std::shared_ptr<scene::Observer> const& observer) = 0;
++    virtual void remove_observer(std::weak_ptr<scene::Observer> const& observer) = 0;
++
  protected:
      InputTargets() = default;
      InputTargets(InputTargets const&) = delete;
 === modified file 'include/server/mir/input/surface.h'
 --- include/server/mir/input/surface.h	2014-06-03 11:04:15 +0000
 +++ include/server/mir/input/surface.h	2014-06-23 02:58:32 +0000
@@ -28,6 +28,16 @@
  namespace mir
+ {
++namespace graphics
++{
++class CursorImage;
++}
++
++namespace scene
++{
++class SurfaceObserver;
++}
++
  namespace input
+ {
  class InputChannel;
@@ -39,6 +49,7 @@
      virtual geometry::Rectangle input_bounds() const = 0;
      virtual bool input_area_contains(geometry::Point const& point) const = 0;
      virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
++    virtual std::shared_ptr<graphics::CursorImage> cursor_image() const = 0;
      virtual InputReceptionMode reception_mode() const = 0;
  protected:
 === modified file 'include/server/mir/scene/surface.h'
 --- include/server/mir/scene/surface.h	2014-06-19 11:35:40 +0000
 +++ include/server/mir/scene/surface.h	2014-06-23 02:58:32 +0000
@@ -74,7 +74,7 @@
      virtual void force_requests_to_complete() = 0;
      virtual void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) = 0;
--    virtual std::shared_ptr<graphics::CursorImage> cursor_image() = 0;
++    virtual std::shared_ptr<graphics::CursorImage> cursor_image() const = 0;
      virtual void add_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
      virtual void remove_observer(std::weak_ptr<SurfaceObserver> const& observer) = 0;
 === modified file 'include/shared/mir_toolkit/common.h'
 --- include/shared/mir_toolkit/common.h	2014-06-20 12:05:55 +0000
 +++ include/shared/mir_toolkit/common.h	2014-06-23 02:58:32 +0000
@@ -133,6 +133,17 @@
      mir_orientation_right = 270
  } MirOrientation;
++/**
++ * A special cursor name for use with mir_cursor_configuration_from_name
++ * representing the system default cursor.
++ */
++extern char const *const mir_default_cursor_name;
++/**
++ * A special cursor name for use with mir_cursor_configuration_from_name
++ * representing a disabled cursor image.
++ */
++extern char const *const mir_disabled_cursor_name;
++
  /**@}*/
  #endif
 === modified file 'include/test/mir_test_doubles/mock_input_surface.h'
 --- include/test/mir_test_doubles/mock_input_surface.h	2014-06-03 11:04:15 +0000
 +++ include/test/mir_test_doubles/mock_input_surface.h	2014-06-23 02:58:32 +0000
@@ -32,25 +32,12 @@
  class MockInputSurface : public input::Surface
+ {
  public:
--    MockInputSurface()
--    {
--        using namespace ::testing;
--        ON_CALL(*this, input_bounds())
--            .WillByDefault(Return(geometry::Rectangle()));
--        static std::string n;
--        ON_CALL(*this, name())
--            .WillByDefault(Return(n));
--        static std::shared_ptr<input::InputChannel> c{nullptr};
--        ON_CALL(*this, input_channel())
--            .WillByDefault(Return(c));
--        ON_CALL(*this, reception_mode())
--            .WillByDefault(Return(input::InputReceptionMode::normal));
--    }
      ~MockInputSurface() noexcept {}
      MOCK_CONST_METHOD0(name, std::string());
      MOCK_CONST_METHOD0(input_bounds, geometry::Rectangle());
      MOCK_CONST_METHOD1(input_area_contains, bool(geometry::Point const&));
      MOCK_CONST_METHOD0(input_channel, std::shared_ptr<input::InputChannel>());
++    MOCK_CONST_METHOD0(cursor_image, std::shared_ptr<graphics::CursorImage>());
      MOCK_CONST_METHOD0(reception_mode, input::InputReceptionMode());
  };
 === modified file 'include/test/mir_test_doubles/stub_input_surface.h'
 --- include/test/mir_test_doubles/stub_input_surface.h	2014-05-14 16:50:03 +0000
 +++ include/test/mir_test_doubles/stub_input_surface.h	2014-06-23 02:58:32 +0000
@@ -50,6 +50,8 @@
      std::string name() const { return {}; }
      mir::geometry::Rectangle input_bounds() const override { return {{},{}}; }
      bool input_area_contains(mir::geometry::Point const&) const { return false; }
++
++    std::shared_ptr<graphics::CursorImage> cursor_image() const { return nullptr; }
      std::shared_ptr<mir::input::InputChannel> const channel;
  };
 === modified file 'include/test/mir_test_doubles/stub_input_targets.h'
 --- include/test/mir_test_doubles/stub_input_targets.h	2014-04-01 22:48:55 +0000
 +++ include/test/mir_test_doubles/stub_input_targets.h	2014-06-23 02:58:32 +0000
@@ -33,6 +33,12 @@
      void for_each(std::function<void(std::shared_ptr<input::Surface> const&)> const& ) override
+     {
+     }
++    void add_observer(std::shared_ptr<scene::Observer> const& /* observer */)
++    {
++    }
++    void remove_observer(std::weak_ptr<scene::Observer> const& /* observer */)
++    {
++    }
  };
+ }
 === modified file 'include/test/mir_test_doubles/stub_scene_surface.h'
 --- include/test/mir_test_doubles/stub_scene_surface.h	2014-06-19 11:35:40 +0000
 +++ include/test/mir_test_doubles/stub_scene_surface.h	2014-06-23 02:58:32 +0000
@@ -86,7 +86,7 @@
      void set_reception_mode(input::InputReceptionMode mode) override { input_mode = mode; }
      void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& /* image */) {}
--    std::shared_ptr<graphics::CursorImage> cursor_image() { return {}; }
++    std::shared_ptr<graphics::CursorImage> cursor_image() const { return {}; }
      MirPixelFormat pixel_format() const override { return mir_pixel_format_xrgb_8888; }
 === modified file 'include/test/mir_test_framework/stubbed_server_configuration.h'
 --- include/test/mir_test_framework/stubbed_server_configuration.h	2014-06-17 11:21:31 +0000
 +++ include/test/mir_test_framework/stubbed_server_configuration.h	2014-06-23 02:58:32 +0000
@@ -47,6 +47,8 @@
      std::shared_ptr<input::InputDispatcher> the_input_dispatcher() override;
      std::shared_ptr<shell::InputTargeter> the_input_targeter() override;
++    std::shared_ptr<graphics::Cursor> the_cursor() override;
++
  private:
      std::shared_ptr<graphics::Platform> graphics_platform;
      std::vector<geometry::Rectangle> const display_rects;
 === modified file 'src/client/cursor_configuration.h'
 --- src/client/cursor_configuration.h	2014-05-14 16:50:03 +0000
 +++ src/client/cursor_configuration.h	2014-06-23 02:58:32 +0000
@@ -25,6 +25,8 @@
  // Will grow to include cursors specified by raw RGBA data, hotspots, etc...
  struct MirCursorConfiguration
+ {
++    MirCursorConfiguration(char const* name);
++
      std::string name;
  };
 === modified file 'src/client/mir_cursor_api.cpp'
 --- src/client/mir_cursor_api.cpp	2014-05-14 16:50:03 +0000
 +++ src/client/mir_cursor_api.cpp	2014-06-23 02:58:32 +0000
@@ -19,9 +19,15 @@
  #include "mir_toolkit/mir_cursor_configuration.h"
  #include "cursor_configuration.h"
++#include <memory>
++
  char const *const mir_default_cursor_name = "default";
--char const *const mir_disabled_cursor_name = nullptr;
++char const *const mir_disabled_cursor_name = "disabled";
++MirCursorConfiguration::MirCursorConfiguration(char const* name) :
++    name{name ? name : std::string()}
++{
++}
  void mir_cursor_configuration_destroy(MirCursorConfiguration *cursor)
+ {
@@ -32,10 +38,7 @@
+ {
      try
+     {
--        auto c = new MirCursorConfiguration;
--        c->name = std::string(name);
--
--        return c;
++        return new MirCursorConfiguration(name);
+     }
      catch (...)
+     {
 === modified file 'src/client/mir_surface.cpp'
 --- src/client/mir_surface.cpp	2014-06-19 16:15:42 +0000
 +++ src/client/mir_surface.cpp	2014-06-23 02:58:32 +0000
@@ -326,7 +326,7 @@
+     {
          std::unique_lock<decltype(mutex)> lock(mutex);
          setting.mutable_surfaceid()->CopyFrom(surface.id());
--        if (cursor->name != "")
++        if (cursor && cursor->name != mir_disabled_cursor_name)
              setting.set_name(cursor->name.c_str());
+     }
 === modified file 'src/server/default_server_configuration.cpp'
 --- src/server/default_server_configuration.cpp	2014-06-11 16:11:32 +0000
 +++ src/server/default_server_configuration.cpp	2014-06-23 02:58:32 +0000
@@ -101,30 +101,6 @@
          });
+ }
--std::shared_ptr<mi::CursorListener>
--mir::DefaultServerConfiguration::the_cursor_listener()
--{
--    struct DefaultCursorListener : mi::CursorListener
--    {
--        DefaultCursorListener(std::shared_ptr<mg::Cursor> const& cursor) :
--            cursor(cursor)
--        {
--        }
--
--        void cursor_moved_to(float abs_x, float abs_y)
--        {
--            cursor->move_to(geom::Point{abs_x, abs_y});
--        }
--
--        std::shared_ptr<mg::Cursor> const cursor;
--    };
--    return cursor_listener(
--        [this]() -> std::shared_ptr<mi::CursorListener>
--        {
--            return std::make_shared<DefaultCursorListener>(the_cursor());
--        });
--}
--
  std::shared_ptr<ms::SurfaceConfigurator> mir::DefaultServerConfiguration::the_surface_configurator()
+ {
      struct DefaultSurfaceConfigurator : public ms::SurfaceConfigurator
 === modified file 'src/server/graphics/default_configuration.cpp'
 --- src/server/graphics/default_configuration.cpp	2014-06-10 14:40:23 +0000
 +++ src/server/graphics/default_configuration.cpp	2014-06-23 02:58:32 +0000
@@ -34,6 +34,8 @@
  #include "mir/abnormal_exit.h"
  #include "mir/emergency_cleanup.h"
++#include "mir_toolkit/common.h"
++
  #include <boost/throw_exception.hpp>
  #include "builtin_cursor_images.h"
@@ -138,7 +140,7 @@
      return default_cursor_image(
          [this]()
+         {
--            return the_cursor_images()->image("arrow", default_cursor_size);
++            return the_cursor_images()->image(mir_default_cursor_name, default_cursor_size);
          });
+ }
 === modified file 'src/server/input/CMakeLists.txt'
 --- src/server/input/CMakeLists.txt	2014-06-02 17:07:02 +0000
 +++ src/server/input/CMakeLists.txt	2014-06-23 02:58:32 +0000
@@ -10,6 +10,7 @@
    nested_input_configuration.cpp
    display_input_region.cpp
    vt_filter.cpp
++  cursor_controller.cpp
    default_configuration.cpp
+ )
 === added file 'src/server/input/cursor_controller.cpp'
 --- src/server/input/cursor_controller.cpp	1970-01-01 00:00:00 +0000
 +++ src/server/input/cursor_controller.cpp	2014-06-23 02:58:32 +0000
@@ -0,0 +1,244 @@
++/*
++ * Copyright © 2014 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: Robert Carr <robert.carr@canonical.com>
++ */
++
++#include "cursor_controller.h"
++
++#include "mir/input/input_targets.h"
++#include "mir/input/surface.h"
++#include "mir/graphics/cursor.h"
++#include "mir/scene/observer.h"
++#include "mir/scene/surface_observer.h"
++#include "mir/scene/surface.h"
++
++#include <functional>
++#include <mutex>
++#include <map>
++
++#include <assert.h>
++
++namespace mi = mir::input;
++namespace mg = mir::graphics;
++namespace ms = mir::scene;
++namespace geom = mir::geometry;
++
++namespace
++{
++
++struct UpdateCursorOnSurfaceChanges : ms::SurfaceObserver
++{
++    UpdateCursorOnSurfaceChanges(mi::CursorController* cursor_controller)
++        : cursor_controller(cursor_controller)
++    {
++    }
++
++    void attrib_changed(MirSurfaceAttrib, int) override
++    {
++        // Attribute changing alone wont trigger a cursor update
++    }
++    void resized_to(geom::Size const&) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void moved_to(geom::Point const&) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void hidden_set_to(bool) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void frame_posted(int) override
++    {
++        // Frame posting wont trigger a cursor update
++    }
++    void alpha_set_to(float) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void transformation_set_to(glm::mat4 const&) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void reception_mode_set_to(mi::InputReceptionMode) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void cursor_image_set_to(mg::CursorImage const&) override
++    {
++        cursor_controller->update_cursor_image();
++    }
++    void orientation_set_to(MirOrientation /* orientation */) override
++    {
++        // No need to update cursor for orientation property change alone.
++    }
++
++    mi::CursorController* const cursor_controller;
++};
++
++struct UpdateCursorOnSceneChanges : ms::Observer
++{
++    UpdateCursorOnSceneChanges(mi::CursorController* cursor_controller)
++        : cursor_controller(cursor_controller)
++    {
++    }
++
++    void add_surface_observer(ms::Surface* surface)
++    {
++        auto const observer = std::make_shared<UpdateCursorOnSurfaceChanges>(cursor_controller);
++        surface->add_observer(observer);
++
++        {
++            std::unique_lock<decltype(surface_observers_guard)> lg(surface_observers_guard);
++            surface_observers[surface] = observer;
++        }
++    }
++
++    void surface_added(ms::Surface *surface)
++    {
++        add_surface_observer(surface);
++        cursor_controller->update_cursor_image();
++    }
++    void surface_removed(ms::Surface *surface)
++    {
++        {
++            std::unique_lock<decltype(surface_observers_guard)> lg(surface_observers_guard);
++            auto it = surface_observers.find(surface);
++            if (it != surface_observers.end())
++            {
++                surface->remove_observer(it->second);
++                surface_observers.erase(it);
++            }
++        }
++        cursor_controller->update_cursor_image();
++    }
++    void surfaces_reordered()
++    {
++        cursor_controller->update_cursor_image();
++    }
++
++    void surface_exists(ms::Surface *surface)
++    {
++        add_surface_observer(surface);
++        cursor_controller->update_cursor_image();
++    }
++
++    void end_observation()
++    {
++        std::unique_lock<decltype(surface_observers_guard)> lg(surface_observers_guard);
++        for (auto &kv : surface_observers)
++        {
++                auto surface = kv.first;
++                if (surface)
++                    surface->remove_observer(kv.second);
++        }
++        surface_observers.clear();
++    }
++
++private:
++    mi::CursorController* const cursor_controller;
++
++    std::mutex surface_observers_guard;
++    std::map<ms::Surface*, std::weak_ptr<ms::SurfaceObserver>> surface_observers;
++};
++
++std::shared_ptr<mi::Surface> topmost_surface_containing_point(
++    std::shared_ptr<mi::InputTargets> const& targets, geom::Point const& point)
++{
++    std::shared_ptr<mi::Surface> top_surface_at_point;
++    targets->for_each([&top_surface_at_point, &point]
++        (std::shared_ptr<mi::Surface> const& surface)
++        {
++            if (surface->input_area_contains(point))
++                top_surface_at_point = surface;
++        });
++    return top_surface_at_point;
++}
++
++}
++
++mi::CursorController::CursorController(std::shared_ptr<mi::InputTargets> const& input_targets,
++    std::shared_ptr<mg::Cursor> const& cursor,
++    std::shared_ptr<mg::CursorImage> const& default_cursor_image) :
++        input_targets(input_targets),
++        cursor(cursor),
++        default_cursor_image(default_cursor_image),
++        current_cursor(default_cursor_image)
++{
++    // TODO: Add observer could return weak_ptr to eliminate this
++    // pattern
++    auto strong_observer = std::make_shared<UpdateCursorOnSceneChanges>(this);
++    input_targets->add_observer(strong_observer);
++    observer = strong_observer;
++}
++
++mi::CursorController::~CursorController()
++{
++    try
++    {
++        input_targets->remove_observer(observer);
++    }
++    catch (...)
++    {
++        std::terminate();
++    }
++}
++
++void mi::CursorController::set_cursor_image_locked(std::lock_guard<std::mutex> const&,
++    std::shared_ptr<mg::CursorImage> const& image)
++{
++    if (current_cursor == image)
++    {
++        return;
++    }
++
++    current_cursor = image;
++    if (image)
++        cursor->show(*image);
++    else
++        cursor->hide();
++}
++
++void mi::CursorController::update_cursor_image_locked(std::lock_guard<std::mutex> const& lg)
++{
++    auto surface = topmost_surface_containing_point(input_targets, cursor_location);
++    if (surface)
++    {
++        set_cursor_image_locked(lg, surface->cursor_image());
++    }
++    else
++    {
++        set_cursor_image_locked(lg, default_cursor_image);
++    }
++}
++
++void mi::CursorController::update_cursor_image()
++{
++    std::lock_guard<std::mutex> lg(cursor_state_guard);
++    update_cursor_image_locked(lg);
++}
++
++void mi::CursorController::cursor_moved_to(float abs_x, float abs_y)
++{
++    std::lock_guard<std::mutex> lg(cursor_state_guard);
++
++    cursor_location = geom::Point{geom::X{abs_x}, geom::Y{abs_y}};
++
++    update_cursor_image_locked(lg);
++
++    cursor->move_to(cursor_location);
++}
 === added file 'src/server/input/cursor_controller.h'
 --- src/server/input/cursor_controller.h	1970-01-01 00:00:00 +0000
 +++ src/server/input/cursor_controller.h	2014-06-23 02:58:32 +0000
@@ -0,0 +1,77 @@
++/*
++ * Copyright © 2014 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: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_INPUT_CURSOR_CONTROLLER_H_
++#define MIR_INPUT_CURSOR_CONTROLLER_H_
++
++#include "mir/input/cursor_listener.h"
++#include "mir/geometry/point.h"
++
++#include <memory>
++#include <mutex>
++
++namespace mir
++{
++namespace graphics
++{
++class Cursor;
++class CursorImage;
++}
++namespace scene
++{
++class Observer;
++}
++
++namespace input
++{
++class InputTargets;
++
++class CursorController : public CursorListener
++{
++public:
++    CursorController(std::shared_ptr<InputTargets> const& input_targets,
++        std::shared_ptr<graphics::Cursor> const& cursor,
++        std::shared_ptr<graphics::CursorImage> const& default_cursor_image);
++    virtual ~CursorController();
++
++    void cursor_moved_to(float abs_x, float abs_y);
++
++    // Trigger an update of the cursor image without cursor motion, e.g.
++    // in response to scene changes.
++    void update_cursor_image();
++
++private:
++    std::shared_ptr<InputTargets> const input_targets;
++    std::shared_ptr<graphics::Cursor> const cursor;
++    std::shared_ptr<graphics::CursorImage> const default_cursor_image;
++
++    std::mutex cursor_state_guard;
++    geometry::Point cursor_location;
++    std::shared_ptr<graphics::CursorImage> current_cursor;
++
++    std::weak_ptr<scene::Observer> observer;
++
++
++    void update_cursor_image_locked(std::lock_guard<std::mutex> const&);
++    void set_cursor_image_locked(std::lock_guard<std::mutex> const&, std::shared_ptr<graphics::CursorImage> const& image);
++};
++
++}
++}
++
++#endif // MIR_INPUT_CURSOR_CONTROLLER_H_
 === modified file 'src/server/input/default_configuration.cpp'
 --- src/server/input/default_configuration.cpp	2014-06-06 10:03:54 +0000
 +++ src/server/input/default_configuration.cpp	2014-06-23 02:58:32 +0000
@@ -28,6 +28,7 @@
  #include "event_filter_chain.h"
  #include "nested_input_configuration.h"
  #include "null_input_configuration.h"
++#include "cursor_controller.h"
  #include "null_input_dispatcher.h"
  #include "null_input_targeter.h"
@@ -193,4 +194,14 @@
      return the_input_configuration()->the_input_channel_factory();
+ }
++std::shared_ptr<mi::CursorListener>
++mir::DefaultServerConfiguration::the_cursor_listener()
++{
++    return cursor_listener(
++        [this]() -> std::shared_ptr<mi::CursorListener>
++        {
++            return std::make_shared<mi::CursorController>(the_input_targets(),
++                the_cursor(), the_default_cursor_image());
++        });
++}
 === modified file 'src/server/scene/basic_surface.cpp'
 --- src/server/scene/basic_surface.cpp	2014-06-20 12:05:55 +0000
 +++ src/server/scene/basic_surface.cpp	2014-06-23 02:58:32 +0000
@@ -504,13 +504,16 @@
  void ms::BasicSurface::set_cursor_image(std::shared_ptr<mg::CursorImage> const& image)
+ {
++    {
          std::unique_lock<std::mutex> lock(guard);
          cursor_image_ = image;
++    }
--        observers.cursor_image_set_to(*image);
++    observers.cursor_image_set_to(*image);
+ }
--std::shared_ptr<mg::CursorImage> ms::BasicSurface::cursor_image()
++
++std::shared_ptr<mg::CursorImage> ms::BasicSurface::cursor_image() const
+ {
      std::unique_lock<std::mutex> lock(guard);
      return cursor_image_;
 === modified file 'src/server/scene/basic_surface.h'
 --- src/server/scene/basic_surface.h	2014-06-20 12:05:55 +0000
 +++ src/server/scene/basic_surface.h	2014-06-23 02:58:32 +0000
@@ -140,7 +140,7 @@
      void show() override;
      void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image);
--    std::shared_ptr<graphics::CursorImage> cursor_image();
++    std::shared_ptr<graphics::CursorImage> cursor_image() const;
      void add_observer(std::shared_ptr<SurfaceObserver> const& observer) override;
      void remove_observer(std::weak_ptr<SurfaceObserver> const& observer) override;
 === modified file 'tests/acceptance-tests/test_client_cursor_api.cpp'
 --- tests/acceptance-tests/test_client_cursor_api.cpp	2014-06-19 00:02:28 +0000
 +++ tests/acceptance-tests/test_client_cursor_api.cpp	2014-06-23 02:58:32 +0000
@@ -23,7 +23,6 @@
  #include "mir/scene/surface_factory.h"
  #include "mir/scene/null_observer.h"
  #include "mir/scene/null_surface_observer.h"
--#include "mir/compositor/scene.h"
  #include "mir_toolkit/mir_client_library.h"
@@ -31,6 +30,7 @@
  #include "mir_test/fake_shared.h"
  #include "mir_test/event_factory.h"
  #include "mir_test/wait_condition.h"
++#include "mir_test_framework/server_runner.h"
  #include "mir_test_framework/display_server_test_fixture.h"
  #include "mir_test_framework/input_testing_server_configuration.h"
  #include "mir_test_framework/input_testing_client_configuration.h"
@@ -59,7 +59,11 @@
      MOCK_METHOD1(show, void(mg::CursorImage const&));
      MOCK_METHOD0(hide, void());
--    MOCK_METHOD1(move_to, void(geom::Point));
++    // We are not interested in mocking the motion in these tests as we
++    // generate it ourself.
++    void move_to(geom::Point)
++    {
++    }
  };
  struct NamedCursorImage : public mg::CursorImage
@@ -101,133 +105,87 @@
      return cursor_is_named(arg, name);
+ }
--struct CursorSettingClient : mtf::TestingClientConfiguration
++struct ClientConfig : mtf::TestingClientConfiguration
+ {
--    static std::string const mir_test_socket;
++    std::string connect_string;
      std::string const client_name;
--    mtf::CrossProcessSync set_cursor_complete;
--    mtf::CrossProcessSync client_may_exit;
++    mt::Barrier& set_cursor_complete;
++    mt::Barrier& client_may_exit;
--    std::function<void(MirSurface*)> const set_cursor;
++    std::function<void(MirSurface*)> set_cursor;
--    CursorSettingClient(std::string const& client_name,
--                        mtf::CrossProcessSync const& cursor_ready_fence,
--                        mtf::CrossProcessSync const& client_may_exit_fence,
--                        std::function<void(MirSurface*)> const& set_cursor)
++    ClientConfig(std::string const& client_name,
++                        mt::Barrier& cursor_ready_fence,
++                        mt::Barrier& client_may_exit_fence)
          : client_name(client_name),
            set_cursor_complete(cursor_ready_fence),
--          client_may_exit(client_may_exit_fence),
--          set_cursor(set_cursor)
--    {
--    }
++          client_may_exit(client_may_exit_fence)
++    {
++    }
++
++    virtual void thread_exec()
++    {
++        auto connection = mir_connect_sync(connect_string.c_str(),
++                                           client_name.c_str());
++
++        ASSERT_TRUE(connection != NULL);
++        MirSurfaceParameters const request_params =
++            {
++                client_name.c_str(),
++                // For this fixture, we force geometry on server side
++                0, 0,
++                mir_pixel_format_abgr_8888,
++                mir_buffer_usage_hardware,
++                mir_display_output_id_invalid
++            };
++        auto surface = mir_connection_create_surface_sync(connection, &request_params);
++
++        set_cursor(surface);
++        set_cursor_complete.ready();
++
++        client_may_exit.ready();
++
++        mir_surface_release_sync(surface);
++        mir_connection_release(connection);
++    }
++    void tear_down() { if (thread.joinable()) thread.join(); }
      void exec() override
+     {
--        auto connection = mir_connect_sync(mir_test_socket.c_str(),
--                                           client_name.c_str());
--
--        ASSERT_TRUE(connection != NULL);
--        MirSurfaceParameters const request_params =
--            {
--                client_name.c_str(),
--                // For this fixture, we force geometry on server side
--                0, 0,
--                mir_pixel_format_abgr_8888,
--                mir_buffer_usage_hardware,
--                mir_display_output_id_invalid
--            };
--        auto surface = mir_connection_create_surface_sync(connection, &request_params);
--
--        set_cursor(surface);
--        set_cursor_complete.signal_ready();
--
--        client_may_exit.wait_for_signal_ready_for();
--
--        mir_surface_release_sync(surface);
--        mir_connection_release(connection);
--    }
--};
--
--std::string const CursorSettingClient::mir_test_socket = mtf::test_socket_file();
--
--struct MockSurfaceObserver : public ms::NullSurfaceObserver
--{
--    MOCK_METHOD1(cursor_image_set_to, void(mg::CursorImage const&));
--};
--
--struct SurfaceObserverInstaller : public ms::NullObserver
--{
--    SurfaceObserverInstaller(std::shared_ptr<ms::SurfaceObserver> const& observer)
--        : observer(observer)
--    {
--    }
--
--    void surface_added(ms::Surface *surf) override
--    {
--        surf->add_observer(observer);
--    }
--
--    std::shared_ptr<ms::SurfaceObserver> const observer;
--};
--
--struct SurfaceObservingServerConfiguration : mtf::TestingServerConfiguration
--{
--    SurfaceObservingServerConfiguration(std::function<void(MockSurfaceObserver&)> const& set_expectations)
--        : set_expectations(set_expectations),
--          observer(std::make_shared<MockSurfaceObserver>())
--    {
--    }
--
--    void on_start() override
--    {
--        auto scene = the_scene();
--        scene->add_observer(std::make_shared<SurfaceObserverInstaller>(observer));
--
--        set_expectations(*observer);
--    }
--
--    std::function<void(MockSurfaceObserver&)> const set_expectations;
--    std::shared_ptr<MockSurfaceObserver> const observer;
--};
--
--typedef unsigned ClientCount;
--struct CursorTestServerConfiguration : mtf::InputTestingServerConfiguration
--{
--    std::shared_ptr<ms::PlacementStrategy> placement_strategy;
--    mtf::CrossProcessSync client_ready_fence;
--    mtf::CrossProcessSync client_may_exit_fence;
--    int const number_of_clients;
--
--    std::function<void(MockCursor&, mt::WaitCondition&)> const expect_cursor_states;
--    std::function<void(CursorTestServerConfiguration*)> const synthesize_cursor_motion;
--
++        thread = std::thread([this]{ thread_exec(); });
++    }
++private:
++    std::thread thread;
++};
++
++struct ServerConfiguration : mtf::InputTestingServerConfiguration
++{
++    mt::Barrier& cursor_configured_fence;
++    mt::Barrier& client_may_exit_fence;
++
++    std::function<void(MockCursor&, mt::WaitCondition&)> expect_cursor_states;
++    std::function<void(ServerConfiguration*)> synthesize_cursor_motion;
++
++    mtf::SurfaceGeometries client_geometries;
++    mtf::SurfaceDepths client_depths;
++
      MockCursor cursor;
--
--    CursorTestServerConfiguration(mtf::SurfaceGeometries surface_geometries_by_name,
--                                  mtf::SurfaceDepths surface_depths_by_name,
--                                  mtf::CrossProcessSync client_ready_fence,
--                                  mtf::CrossProcessSync client_may_exit_fence,
--                                  ClientCount const number_of_clients,
--                                  std::function<void(MockCursor&, mt::WaitCondition&)> const& expect_cursor_states,
--                                  std::function<void(CursorTestServerConfiguration*)> const& synthesize_cursor_motion)
--        : placement_strategy(
--              std::make_shared<mtf::DeclarativePlacementStrategy>(InputTestingServerConfiguration::the_placement_strategy(),
--                  surface_geometries_by_name, surface_depths_by_name)),
--          client_ready_fence(client_ready_fence),
--          client_may_exit_fence(client_may_exit_fence),
--          number_of_clients(number_of_clients),
--          expect_cursor_states(expect_cursor_states),
--          synthesize_cursor_motion(synthesize_cursor_motion)
++
++    ServerConfiguration(mt::Barrier& cursor_configured_fence, mt::Barrier& client_may_exit_fence)
++        : cursor_configured_fence(cursor_configured_fence),
++          client_may_exit_fence(client_may_exit_fence)
+     {
+     }
--
++
      std::shared_ptr<ms::PlacementStrategy> the_placement_strategy() override
+     {
--        return placement_strategy;
++        return std::make_shared<mtf::DeclarativePlacementStrategy>(
++            InputTestingServerConfiguration::the_placement_strategy(),
++            client_geometries, client_depths);
+     }
--
++
      std::shared_ptr<mg::Cursor> the_cursor() override
+     {
          return mt::fake_shared(cursor);
@@ -241,283 +199,332 @@
      void inject_input()
+     {
          using namespace ::testing;
--
--        for (int i = 1; i < number_of_clients + 1; i++)
--            EXPECT_EQ(i, client_ready_fence.wait_for_signal_ready_for());
--
++        cursor_configured_fence.ready();
++
          mt::WaitCondition expectations_satisfied;
--
++
          // Clear any states applied during server initialization.
          Mock::VerifyAndClearExpectations(&cursor);
          expect_cursor_states(cursor, expectations_satisfied);
++
++        // We are only interested in the cursor image changes, not
++        // the synthetic motion.
          synthesize_cursor_motion(this);
          expectations_satisfied.wait_for_at_most_seconds(60);
--
--        EXPECT_CALL(cursor, show(_)).Times(AnyNumber()); // Client shutdown
--        for (int i = 0; i < number_of_clients; i++)
--            client_may_exit_fence.signal_ready();
--    }
--};
--
--}
--
--// TODO: A lot of common code setup in these tests could be moved to
--// a fixture.
--using TestClientCursorAPI = BespokeDisplayServerTestFixture;
--
--TEST_F(TestClientCursorAPI, client_cursor_request_is_made_surface_data)
--{
--    using namespace ::testing;
--
--    static std::string const test_client_name = "1";
--    static std::string const client_1_cursor = "1";
--
--    static mtf::CrossProcessSync client_ready_fence, client_may_exit_fence;
--
--    SurfaceObservingServerConfiguration config([&](MockSurfaceObserver &observer)
--    {
--        EXPECT_CALL(observer, cursor_image_set_to(_)).WillOnce(Invoke(
--        [&](mg::CursorImage const&)
--        {
--            client_may_exit_fence.signal_ready();
--        }));
--        client_ready_fence.signal_ready();
--    });
--    launch_server_process(config);
--
--    CursorSettingClient client1_conf(test_client_name, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
--        {
--            auto conf = mir_cursor_configuration_from_name(client_1_cursor.c_str());
--            mir_wait_for(mir_surface_configure_cursor(surface, conf));
--            mir_cursor_configuration_destroy(conf);
--        });
--    launch_client_process(client1_conf);
++
++        Mock::VerifyAndClearExpectations(&cursor);
++
++        // Client shutdown
++        EXPECT_CALL(cursor, show(_)).Times(AnyNumber());
++        EXPECT_CALL(cursor, hide()).Times(AnyNumber());
++        client_may_exit_fence.ready();
++    }
++
++};
++
++struct DeferredInProcessServer : testing::Test, private mtf::ServerRunner
++{
++    void TearDown() override { ServerRunner::stop_server(); }
++
++    using ServerRunner::start_server;
++    using ServerRunner::new_connection;
++};
++
++struct TestClientCursorAPI : DeferredInProcessServer
++{
++    std::string const client_name_1 = "1";
++    std::string const client_name_2 = "2";
++    std::string const client_cursor_1 = "cursor-1";
++    std::string const client_cursor_2 = "cursor-2";
++
++    // Reset to higher values for more clients.
++    mt::Barrier cursor_configured_fence{2};
++    mt::Barrier client_may_exit_fence{2};
++
++    ServerConfiguration server_configuration{cursor_configured_fence, client_may_exit_fence};
++    mir::DefaultServerConfiguration& server_config() override { return server_configuration; }
++
++    ClientConfig client_config_1{client_name_1, cursor_configured_fence, client_may_exit_fence};
++    ClientConfig client_config_2{client_name_2, cursor_configured_fence, client_may_exit_fence};
++
++    // Default number allows one client.
++    void set_client_count(unsigned count)
++    {
++        cursor_configured_fence.reset(count + 1);
++        client_may_exit_fence.reset(count + 1);
++    }
++
++    void start_server()
++    {
++        DeferredInProcessServer::start_server();
++        server_configuration.exec();
++    }
++
++    void start_client(ClientConfig& config)
++    {
++        config.connect_string = new_connection();
++        config.exec();
++    }
++
++    void TearDown()
++    {
++        client_config_1.tear_down();
++        client_config_2.tear_down();
++        server_configuration.on_exit();
++        DeferredInProcessServer::TearDown();
++    }
++};
++
+ }
  // In this set we create a 1x1 client surface at the point (1,0). The client requests to disable the cursor
  // over this surface. Since the cursor starts at (0,0) we when we move the cursor by (1,0) thus causing it
  // to enter the bounds of the first surface, we should observe it being disabled.
--// TODO: Enable
--TEST_F(TestClientCursorAPI, DISABLED_client_may_disable_cursor_over_surface)
++TEST_F(TestClientCursorAPI, client_may_disable_cursor_over_surface)
+ {
      using namespace ::testing;
--    std::string const test_client_name = "1";
--    mtf::SurfaceGeometries client_geometries;
--    client_geometries[test_client_name] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
--                                                          geom::Size{geom::Width{1}, geom::Height{1}}};
++    server_configuration.client_geometries[client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
++                                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
--    mtf::CrossProcessSync client_ready_fence, client_may_exit_fence;
--    CursorTestServerConfiguration server_conf(
--        client_geometries, mtf::SurfaceDepths(),
--        client_ready_fence, client_may_exit_fence,
--        ClientCount{1},
--        [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
++    server_configuration.expect_cursor_states = [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
+         {
              EXPECT_CALL(cursor, hide()).Times(1)
                  .WillOnce(mt::WakeUp(&expectations_satisfied));
--        },
--        [](CursorTestServerConfiguration *server)
++        };
++    server_configuration.synthesize_cursor_motion = [](ServerConfiguration *server)
+         {
              server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
--        });
--    launch_server_process(server_conf);
++        };
++    start_server();
--    CursorSettingClient client_conf(test_client_name, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
++    client_config_1.set_cursor = [](MirSurface *surface)
+         {
--            // Disable cursor
--            mir_wait_for(mir_surface_configure_cursor(surface,
--                mir_cursor_configuration_from_name(mir_disabled_cursor_name)));
--        });
--    launch_client_process(client_conf);
++            auto conf = mir_cursor_configuration_from_name(mir_disabled_cursor_name);
++            mir_wait_for(mir_surface_configure_cursor(surface, conf));
++            mir_cursor_configuration_destroy(conf);
++        };
++    start_client(client_config_1);
+ }
--// TODO: Enable
--TEST_F(TestClientCursorAPI, DISABLED_cursor_restored_when_leaving_surface)
++TEST_F(TestClientCursorAPI, cursor_restored_when_leaving_surface)
+ {
      using namespace ::testing;
--    std::string const test_client_name = "1";
--    mtf::SurfaceGeometries client_geometries;
--    client_geometries[test_client_name] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
--                                                          geom::Size{geom::Width{1}, geom::Height{1}}};
++    server_configuration.client_geometries[client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
++                                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
      mtf::CrossProcessSync client_ready_fence, client_may_exit_fence;
--    CursorTestServerConfiguration server_conf(
--        client_geometries, mtf::SurfaceDepths(),
--        client_ready_fence, client_may_exit_fence,
--        ClientCount{1},
--        [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
++    server_configuration.expect_cursor_states = [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
+         {
              InSequence seq;
              EXPECT_CALL(cursor, hide()).Times(1);
              EXPECT_CALL(cursor, show(DefaultCursorImage())).Times(1)
                  .WillOnce(mt::WakeUp(&expectations_satisfied));
--        },
--        [](CursorTestServerConfiguration *server)
++        };
++    server_configuration.synthesize_cursor_motion = [](ServerConfiguration *server)
+         {
              server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
              server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(2,0));
--        });
--    launch_server_process(server_conf);
--
--    CursorSettingClient client_conf(test_client_name, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
--        {
--            // Disable cursor
--            mir_wait_for(mir_surface_configure_cursor(surface,
--                mir_cursor_configuration_from_name(mir_disabled_cursor_name)));
--        });
--    launch_client_process(client_conf);
--}
--
--// TODO: Enable
--TEST_F(TestClientCursorAPI, DISABLED_cursor_changed_when_crossing_surface_boundaries)
--{
--    using namespace ::testing;
--
--    static std::string const test_client_name_1 = "1";
--    static std::string const test_client_name_2 = "2";
--    static std::string const client_1_cursor = test_client_name_1;
--    static std::string const client_2_cursor = test_client_name_2;
--
--    mtf::SurfaceGeometries client_geometries;
--    client_geometries[test_client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
--                                                          geom::Size{geom::Width{1}, geom::Height{1}}};
--    client_geometries[test_client_name_2] = geom::Rectangle{geom::Point{geom::X{2}, geom::Y{0}},
--                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
--
--    mtf::CrossProcessSync client_ready_fence, client_may_exit_fence;
--
--    CursorTestServerConfiguration server_conf(
--        client_geometries, mtf::SurfaceDepths(),
--        client_ready_fence, client_may_exit_fence,
--        ClientCount{2},
--        [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
--        {
--            InSequence seq;
--            EXPECT_CALL(cursor, show(CursorNamed(client_1_cursor))).Times(1);
--            EXPECT_CALL(cursor, show(CursorNamed(client_2_cursor))).Times(1)
--                .WillOnce(mt::WakeUp(&expectations_satisfied));
--        },
--        [](CursorTestServerConfiguration *server)
--        {
--            server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
--            server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
--        });
--    launch_server_process(server_conf);
--
--    CursorSettingClient client1_conf(test_client_name_1, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
--        {
--            mir_wait_for(mir_surface_configure_cursor(surface, mir_cursor_configuration_from_name(client_1_cursor.c_str())));
--        });
--    launch_client_process(client1_conf);
--    CursorSettingClient client2_conf(test_client_name_2, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
--        {
--            // Disable cursor
--            mir_wait_for(mir_surface_configure_cursor(surface, mir_cursor_configuration_from_name(client_2_cursor.c_str())));
--        });
--    launch_client_process(client2_conf);
--}
--
--// TODO: Enable
--TEST_F(TestClientCursorAPI, DISABLED_cursor_request_taken_from_top_surface)
--{
--    using namespace ::testing;
--
--    static std::string const test_client_name_1 = "1";
--    static std::string const test_client_name_2 = "2";
--    static std::string const client_1_cursor = test_client_name_1;
--    static std::string const client_2_cursor = test_client_name_2;
--
--    mtf::SurfaceGeometries client_geometries;
--    client_geometries[test_client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
--                                                          geom::Size{geom::Width{1}, geom::Height{1}}};
--    client_geometries[test_client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
--                                                          geom::Size{geom::Width{1}, geom::Height{1}}};
--    mtf::SurfaceDepths client_depths;
--    client_depths[test_client_name_1] = ms::DepthId{0};
--    client_depths[test_client_name_2] = ms::DepthId{1};
--
--    mtf::CrossProcessSync client_ready_fence, client_may_exit_fence;
--
--    CursorTestServerConfiguration server_conf(
--        client_geometries, client_depths,
--        client_ready_fence, client_may_exit_fence,
--        ClientCount{2},
--        [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
--        {
--            InSequence seq;
--            EXPECT_CALL(cursor, show(CursorNamed(client_2_cursor))).Times(1)
--                .WillOnce(mt::WakeUp(&expectations_satisfied));
--        },
--        [](CursorTestServerConfiguration *server)
--        {
--            server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
--        });
--    launch_server_process(server_conf);
--
--    CursorSettingClient client1_conf(test_client_name_1, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
--        {
--            mir_wait_for(mir_surface_configure_cursor(surface, mir_cursor_configuration_from_name(client_1_cursor.c_str())));
--        });
--    launch_client_process(client1_conf);
--    CursorSettingClient client2_conf(test_client_name_2, client_ready_fence, client_may_exit_fence,
--        [](MirSurface *surface)
--        {
--            mir_wait_for(mir_surface_configure_cursor(surface, mir_cursor_configuration_from_name(client_1_cursor.c_str())));
--        });
--
--    launch_client_process(client2_conf);
--}
--
--// TODO: Enable
--TEST_F(TestClientCursorAPI, DISABLED_cursor_request_applied_without_cursor_motion)
--{
--    using namespace ::testing;
--    static std::string const test_client_name_1 = "1";
--    static std::string const client_1_cursor = test_client_name_1;
--
--    mtf::SurfaceGeometries client_geometries;
--    client_geometries[test_client_name_1] = geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
--                                                          geom::Size{geom::Width{1}, geom::Height{1}}};
--
--    mtf::CrossProcessSync client_ready_fence, client_may_exit_fence;
--    static mtf::CrossProcessSync client_may_change_cursor;
--
--    CursorTestServerConfiguration server_conf(
--        client_geometries, mtf::SurfaceDepths(),
--        client_ready_fence, client_may_exit_fence,
--        ClientCount{1},
--        [](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
--        {
--            InSequence seq;
--            EXPECT_CALL(cursor, show(CursorNamed(client_1_cursor))).Times(1);
++        };
++    start_server();
++
++
++    client_config_1.set_cursor = [](MirSurface *surface)
++        {
++            // Disable cursor
++            auto conf = mir_cursor_configuration_from_name(mir_disabled_cursor_name);
++            mir_wait_for(mir_surface_configure_cursor(surface, conf));
++            mir_cursor_configuration_destroy(conf);
++        };
++    start_client(client_config_1);
++}
++
++TEST_F(TestClientCursorAPI, cursor_changed_when_crossing_surface_boundaries)
++{
++    using namespace ::testing;
++
++    server_configuration.client_geometries[client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
++                                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
++    server_configuration.client_geometries[client_name_2] = geom::Rectangle{geom::Point{geom::X{2}, geom::Y{0}},
++                                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
++    set_client_count(2);
++
++    server_configuration.expect_cursor_states =
++        [this](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
++        {
++            InSequence seq;
++            EXPECT_CALL(cursor, show(CursorNamed(client_cursor_1))).Times(1);
++            EXPECT_CALL(cursor, show(CursorNamed(client_cursor_2))).Times(1)
++                .WillOnce(mt::WakeUp(&expectations_satisfied));
++        };
++    server_configuration.synthesize_cursor_motion =
++        [](ServerConfiguration *server)
++        {
++            server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
++            server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
++        };
++    start_server();
++
++    client_config_1.set_cursor =
++        [this](MirSurface *surface)
++        {
++            auto conf = mir_cursor_configuration_from_name(client_cursor_1.c_str());
++            mir_wait_for(mir_surface_configure_cursor(surface, conf));
++            mir_cursor_configuration_destroy(conf);
++        };
++    start_client(client_config_1);
++
++    client_config_2.set_cursor =
++        [this](MirSurface *surface)
++        {
++            auto conf = mir_cursor_configuration_from_name(client_cursor_2.c_str());
++            mir_wait_for(mir_surface_configure_cursor(surface, conf));
++            mir_cursor_configuration_destroy(conf);
++        };
++    start_client(client_config_2);
++}
++
++TEST_F(TestClientCursorAPI, cursor_request_taken_from_top_surface)
++{
++    using namespace ::testing;
++
++    server_configuration.client_geometries[client_name_1] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
++                                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
++    server_configuration.client_geometries[client_name_2] = geom::Rectangle{geom::Point{geom::X{1}, geom::Y{0}},
++                                                                            geom::Size{geom::Width{1}, geom::Height{1}}};
++    server_configuration.client_depths[client_name_1] = ms::DepthId{0};
++    server_configuration.client_depths[client_name_2] = ms::DepthId{1};
++
++    set_client_count(2);
++
++    server_configuration.expect_cursor_states =
++        [this](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
++        {
++            InSequence seq;
++            EXPECT_CALL(cursor, show(CursorNamed(client_cursor_2))).Times(1)
++                .WillOnce(mt::WakeUp(&expectations_satisfied));
++        };
++    server_configuration.synthesize_cursor_motion =
++        [](ServerConfiguration *server)
++        {
++            server->fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 0));
++        };
++    start_server();
++
++
++    client_config_1.set_cursor =
++        [this](MirSurface *surface)
++        {
++            auto conf = mir_cursor_configuration_from_name(client_cursor_1.c_str());
++            mir_wait_for(mir_surface_configure_cursor(surface, conf));
++            mir_cursor_configuration_destroy(conf);
++        };
++    client_config_2.set_cursor =
++        [this](MirSurface *surface)
++        {
++            auto conf = mir_cursor_configuration_from_name(client_cursor_2.c_str());
++            mir_wait_for(mir_surface_configure_cursor(surface, conf));
++            mir_cursor_configuration_destroy(conf);
++        };
++    start_client(client_config_1);
++    start_client(client_config_2);
++}
++
++namespace
++{
++
++// In the following test the cursor changes are not responsive
++// to cursor motion so we need a different synchronization model.
++struct WaitsToChangeCursorClient : ClientConfig
++{
++    WaitsToChangeCursorClient(std::string const& client_name,
++                              mt::Barrier& cursor_ready_fence,
++                              mt::Barrier& client_may_exit_fence)
++        : ClientConfig(client_name, cursor_ready_fence, client_may_exit_fence)
++    {
++    }
++
++    void thread_exec() override
++    {
++        auto connection = mir_connect_sync(connect_string.c_str(),
++                                           client_name.c_str());
++
++        ASSERT_TRUE(connection != NULL);
++        MirSurfaceParameters const request_params =
++            {
++                client_name.c_str(),
++                // For this fixture, we force geometry on server side
++                0, 0,
++                mir_pixel_format_abgr_8888,
++                mir_buffer_usage_hardware,
++                mir_display_output_id_invalid
++            };
++        auto surface = mir_connection_create_surface_sync(connection, &request_params);
++
++        set_cursor_complete.ready();
++        set_cursor(surface);
++
++        client_may_exit.ready();
++
++        mir_surface_release_sync(surface);
++        mir_connection_release(connection);
++    }
++};
++
++struct TestClientCursorAPINoMotion : TestClientCursorAPI
++{
++    mt::Barrier client_may_change_cursor{2};
++    WaitsToChangeCursorClient waiting_client{client_name_1, cursor_configured_fence, client_may_exit_fence};
++
++    void TearDown() override
++    {
++        waiting_client.tear_down();
++        TestClientCursorAPI::TearDown();
++    }
++};
++
++}
++
++TEST_F(TestClientCursorAPINoMotion, cursor_request_applied_without_cursor_motion)
++{
++    using namespace ::testing;
++
++    server_configuration.client_geometries[client_name_1] =
++        geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
++                        geom::Size{geom::Width{1}, geom::Height{1}}};
++
++    server_configuration.expect_cursor_states =
++        [this](MockCursor& cursor, mt::WaitCondition& expectations_satisfied)
++        {
++            InSequence seq;
++            EXPECT_CALL(cursor, show(CursorNamed(client_cursor_1))).Times(1);
              EXPECT_CALL(cursor, hide()).Times(1)
--                .WillOnce(mt::WakeUp(&expectations_satisfied));
--        },
--        [](CursorTestServerConfiguration * /* server */)
--        {
--            client_may_change_cursor.signal_ready();
--        });
--    launch_server_process(server_conf);
--
--    CursorSettingClient client1_conf(test_client_name_1, client_ready_fence, client_may_exit_fence,
--        [&client_ready_fence](MirSurface *surface)
--        {
--            client_ready_fence.signal_ready();
--            client_may_change_cursor.wait_for_signal_ready_for();
--            mir_wait_for(mir_surface_configure_cursor(surface, mir_cursor_configuration_from_name(client_1_cursor.c_str())));
--            mir_wait_for(mir_surface_configure_cursor(surface,
--                mir_cursor_configuration_from_name(mir_disabled_cursor_name)));
--        });
--    launch_client_process(client1_conf);
++            .WillOnce(mt::WakeUp(&expectations_satisfied));
++        };
++    server_configuration.synthesize_cursor_motion =
++        [this](ServerConfiguration * /* server */)
++        {
++            client_may_change_cursor.ready();
++        };
++    start_server();
++
++    waiting_client.set_cursor =
++        [this](MirSurface *surface)
++        {
++            client_may_change_cursor.ready();
++            auto conf1 = mir_cursor_configuration_from_name(client_cursor_1.c_str());
++            auto conf2 = mir_cursor_configuration_from_name(mir_disabled_cursor_name);
++
++            mir_wait_for(mir_surface_configure_cursor(surface, conf1));
++            mir_wait_for(mir_surface_configure_cursor(surface, conf2));
++
++            mir_cursor_configuration_destroy(conf1);
++            mir_cursor_configuration_destroy(conf2);
++        };
++    start_client(waiting_client);
+ }
++
 === modified file 'tests/mir_test_framework/input_testing_server_options.cpp'
 --- tests/mir_test_framework/input_testing_server_options.cpp	2014-06-03 11:04:15 +0000
 +++ tests/mir_test_framework/input_testing_server_options.cpp	2014-06-23 02:58:32 +0000
@@ -71,12 +71,10 @@
+ {
      if (!input_configuration)
+     {
--        std::shared_ptr<mi::CursorListener> null_cursor_listener{nullptr};
--
          input_configuration = std::make_shared<mtd::FakeEventHubInputConfiguration>(
              the_input_dispatcher(),
              the_input_region(),
--            null_cursor_listener,
++            the_cursor_listener(),
              the_input_report());
          fake_event_hub = input_configuration->the_fake_event_hub();
 === modified file 'tests/mir_test_framework/stubbed_server_configuration.cpp'
 --- tests/mir_test_framework/stubbed_server_configuration.cpp	2014-06-19 09:06:54 +0000
 +++ tests/mir_test_framework/stubbed_server_configuration.cpp	2014-06-23 02:58:32 +0000
@@ -21,6 +21,7 @@
  #include "mir/options/default_configuration.h"
  #include "mir/graphics/buffer_ipc_packer.h"
++#include "mir/graphics/cursor.h"
  #include "mir/input/input_channel.h"
  #include "mir/input/input_manager.h"
@@ -118,6 +119,13 @@
+     }
  };
++class StubCursor : public mg::Cursor
++{
++    void show(mg::CursorImage const&) override {}
++    void hide() override {}
++    void move_to(geom::Point) override {}
++};
++
  class StubGraphicPlatform : public mtd::NullPlatform
+ {
  public:
@@ -162,7 +170,7 @@
+     {
          return std::make_shared<mtd::StubDisplay>(display_rects);
+     }
--
++
      std::vector<geom::Rectangle> const display_rects;
  };
@@ -253,3 +261,9 @@
      else
          return std::make_shared<mi::NullInputDispatcher>();
+ }
++
++std::shared_ptr<mg::Cursor> mtf::StubbedServerConfiguration::the_cursor()
++{
++    return std::make_shared<StubCursor>();
++}
++
 === modified file 'tests/unit-tests/input/CMakeLists.txt'
 --- tests/unit-tests/input/CMakeLists.txt	2013-08-28 03:41:48 +0000
 +++ tests/unit-tests/input/CMakeLists.txt	2014-06-23 02:58:32 +0000
@@ -3,6 +3,7 @@
  list(APPEND UNIT_TEST_SOURCES
    ${CMAKE_CURRENT_SOURCE_DIR}/test_event_filter_chain.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_display_input_region.cpp
++  ${CMAKE_CURRENT_SOURCE_DIR}/test_cursor_controller.cpp
+ )
  set(
 === modified file 'tests/unit-tests/input/android/test_android_input_target_enumerator.cpp'
 --- tests/unit-tests/input/android/test_android_input_target_enumerator.cpp	2014-06-03 11:04:15 +0000
 +++ tests/unit-tests/input/android/test_android_input_target_enumerator.cpp	2014-06-23 02:58:32 +0000
@@ -39,6 +39,7 @@
  namespace mi = mir::input;
  namespace mia = mir::input::android;
++namespace ms = mir::scene;
  namespace geom = mir::geometry;
  namespace mt = mir::test;
@@ -60,6 +61,14 @@
              callback(target);
+     }
++    void add_observer(std::shared_ptr<ms::Observer> const& /* observer */)
++    {
++    }
++
++    void remove_observer(std::weak_ptr<ms::Observer> const& /* observer */)
++    {
++    }
++
      std::vector<std::shared_ptr<mi::Surface>> targets;
  };
 === added file 'tests/unit-tests/input/test_cursor_controller.cpp'
 --- tests/unit-tests/input/test_cursor_controller.cpp	1970-01-01 00:00:00 +0000
 +++ tests/unit-tests/input/test_cursor_controller.cpp	2014-06-23 02:58:32 +0000
@@ -0,0 +1,391 @@
++/*
++ * Copyright © 2014 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: Robert Carr <robert.carr@canonical.com>
++ */
++
++#include "src/server/input/cursor_controller.h"
++
++#include "mir/input/surface.h"
++#include "mir/input/input_targets.h"
++#include "mir/scene/observer.h"
++#include "mir/scene/surface_observer.h"
++#include "mir/graphics/cursor_image.h"
++#include "mir/graphics/cursor.h"
++
++#include "mir_toolkit/common.h"
++
++#include "mir_test/fake_shared.h"
++#include "mir_test_doubles/stub_scene_surface.h"
++
++#include <gtest/gtest.h>
++#include <gmock/gmock.h>
++
++#include <initializer_list>
++#include <mutex>
++#include <algorithm>
++
++#include <assert.h>
++
++namespace mi = mir::input;
++namespace mg = mir::graphics;
++namespace ms = mir::scene;
++namespace geom = mir::geometry;
++namespace mt = mir::test;
++namespace mtd = mt::doubles;
++
++namespace
++{
++
++struct NamedCursorImage : public mg::CursorImage
++{
++    NamedCursorImage(std::string const& name)
++        : cursor_name(name)
++    {
++    }
++
++    void const* as_argb_8888() const { return nullptr; }
++    geom::Size size() const { return geom::Size{}; }
++
++    std::string const cursor_name;
++};
++
++bool cursor_is_named(mg::CursorImage const& i, std::string const& name)
++{
++    auto image = dynamic_cast<NamedCursorImage const*>(&i);
++    assert(image);
++
++    return image->cursor_name == name;
++}
++
++MATCHER(DefaultCursorImage, "")
++{
++    return cursor_is_named(arg, mir_default_cursor_name);
++}
++
++MATCHER_P(CursorNamed, name, "")
++{
++    return cursor_is_named(arg, name);
++}
++
++struct MockCursor : public mg::Cursor
++{
++    MOCK_METHOD1(show, void(mg::CursorImage const&));
++    MOCK_METHOD0(hide, void());
++
++    MOCK_METHOD1(move_to, void(geom::Point));
++};
++
++// TODO: This should only inherit from mi::Surface but to use the Scene observer we need an
++// ms::Surface base class.
++struct StubInputSurface : public mtd::StubSceneSurface
++{
++    StubInputSurface(geom::Rectangle const& input_bounds, std::shared_ptr<mg::CursorImage> const& cursor_image)
++        : mtd::StubSceneSurface(0),
++          bounds(input_bounds),
++          cursor_image_(cursor_image)
++    {
++    }
++
++    std::string name() const override
++    {
++        return std::string();
++    }
++
++    geom::Rectangle input_bounds() const override
++    {
++        // We could return bounds here but lets make sure the cursor controller
++        // is only using input_area_contains.
++        return geom::Rectangle();
++    }
++
++    bool input_area_contains(geom::Point const& point) const override
++    {
++        return bounds.contains(point);
++    }
++
++    std::shared_ptr<mi::InputChannel> input_channel() const override
++    {
++        return nullptr;
++    }
++
++    mi::InputReceptionMode reception_mode() const override
++    {
++        return mi::InputReceptionMode::normal;
++    }
++
++    std::shared_ptr<mg::CursorImage> cursor_image() const override
++    {
++        return cursor_image_;
++    }
++
++    void set_cursor_image(std::shared_ptr<mg::CursorImage> const& image) override
++    {
++        cursor_image_ = image;
++
++        {
++            std::unique_lock<decltype(observer_guard)> lk(observer_guard);
++            for (auto o : observers)
++                o->cursor_image_set_to(*image);
++        }
++    }
++
++    void add_observer(std::shared_ptr<ms::SurfaceObserver> const& observer) override
++    {
++        std::unique_lock<decltype(observer_guard)> lk(observer_guard);
++
++        observers.push_back(observer);
++    }
++
++    void remove_observer(std::weak_ptr<ms::SurfaceObserver> const& observer) override
++    {
++        auto o = observer.lock();
++        assert(o);
++
++        auto it = std::find(observers.begin(), observers.end(), o);
++        observers.erase(it);
++    }
++
++    geom::Rectangle const bounds;
++    std::shared_ptr<mg::CursorImage> cursor_image_;
++
++    std::mutex observer_guard;
++    std::vector<std::shared_ptr<ms::SurfaceObserver>> observers;
++};
++
++struct StubInputTargets : public mi::InputTargets
++{
++    StubInputTargets(std::initializer_list<std::shared_ptr<ms::Surface>> const& targets)
++        : targets(targets.begin(), targets.end())
++    {
++    }
++
++    void for_each(std::function<void(std::shared_ptr<mi::Surface> const&)> const& callback) override
++    {
++        for (auto const& target : targets)
++            callback(target);
++    }
++
++    void add_observer(std::shared_ptr<ms::Observer> const& observer) override
++    {
++        std::unique_lock<decltype(observer_guard)> lk(observer_guard);
++
++        observers.push_back(observer);
++
++        for (auto target : targets)
++        {
++            for (auto observer : observers)
++            {
++                observer->surface_exists(target.get());
++            }
++        }
++    }
++
++    void remove_observer(std::weak_ptr<ms::Observer> const& observer) override
++    {
++        std::unique_lock<decltype(observer_guard)> lk(observer_guard);
++
++        auto o = observer.lock();
++        assert(o);
++
++        auto it = std::find(observers.begin(), observers.end(), o);
++        observers.erase(it);
++    }
++
++    void add_surface(std::shared_ptr<StubInputSurface> const& surface)
++    {
++        targets.push_back(surface);
++        for (auto observer : observers)
++        {
++            observer->surface_added(surface.get());
++        }
++    }
++
++    // TODO: Should be mi::Surface. See comment on StubInputSurface.
++    std::vector<std::shared_ptr<ms::Surface>> targets;
++
++    std::mutex observer_guard;
++
++    std::vector<std::shared_ptr<ms::Observer>> observers;
++};
++
++struct TestCursorController : public testing::Test
++{
++    TestCursorController()
++        : default_cursor_image(std::make_shared<NamedCursorImage>(mir_default_cursor_name))
++    {
++    }
++    geom::Rectangle const rect_0_0_1_1{{0, 0}, {1, 1}};
++    geom::Rectangle const rect_1_1_1_1{{1, 1}, {1, 1}};
++    std::string const cursor_name_1 = "test-cursor-1";
++    std::string const cursor_name_2 = "test-cursor-2";
++
++    MockCursor cursor;
++    std::shared_ptr<mg::CursorImage> const default_cursor_image;
++};
++
++}
++
++TEST_F(TestCursorController, moves_cursor)
++{
++    using namespace ::testing;
++
++    StubInputTargets targets({});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    InSequence seq;
++    EXPECT_CALL(cursor, move_to(geom::Point{geom::X{1.0f}, geom::Y{1.0f}}));
++    EXPECT_CALL(cursor, move_to(geom::Point{geom::X{0.0f}, geom::Y{0.0f}}));
++
++    controller.cursor_moved_to(1.0f, 1.0f);
++    controller.cursor_moved_to(0.0f, 0.0f);
++}
++
++TEST_F(TestCursorController, updates_cursor_image_when_entering_surface)
++{
++    using namespace ::testing;
++
++    StubInputSurface surface{rect_1_1_1_1,
++        std::make_shared<NamedCursorImage>(cursor_name_1)};
++    StubInputTargets targets({mt::fake_shared(surface)});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++    EXPECT_CALL(cursor, show(CursorNamed(cursor_name_1))).Times(1);
++
++    controller.cursor_moved_to(1.0f, 1.0f);
++}
++
++TEST_F(TestCursorController, surface_with_no_cursor_image_hides_cursor)
++{
++    using namespace ::testing;
++
++    StubInputSurface surface{rect_1_1_1_1,
++        nullptr};
++    StubInputTargets targets({mt::fake_shared(surface)});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++    EXPECT_CALL(cursor, hide()).Times(1);
++
++    controller.cursor_moved_to(1.0f, 1.0f);
++}
++
++TEST_F(TestCursorController, takes_cursor_image_from_topmost_surface)
++{
++    using namespace ::testing;
++
++    StubInputSurface surface_1{rect_1_1_1_1, std::make_shared<NamedCursorImage>(cursor_name_1)};
++    StubInputSurface surface_2{rect_1_1_1_1, std::make_shared<NamedCursorImage>(cursor_name_2)};
++    StubInputTargets targets({mt::fake_shared(surface_1), mt::fake_shared(surface_2)});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++    EXPECT_CALL(cursor, show(CursorNamed(cursor_name_2))).Times(1);
++
++    controller.cursor_moved_to(1.0f, 1.0f);
++}
++
++TEST_F(TestCursorController, restores_cursor_when_leaving_surface)
++{
++    using namespace ::testing;
++
++    StubInputSurface surface{rect_1_1_1_1,
++        std::make_shared<NamedCursorImage>(cursor_name_1)};
++    StubInputTargets targets({mt::fake_shared(surface)});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++
++    {
++        InSequence seq;
++        EXPECT_CALL(cursor, show(CursorNamed(cursor_name_1))).Times(1);
++        EXPECT_CALL(cursor, show(DefaultCursorImage())).Times(1);
++    }
++
++    controller.cursor_moved_to(1.0f, 1.0f);
++    controller.cursor_moved_to(2.0f, 2.0f);
++}
++
++TEST_F(TestCursorController, change_in_cursor_request_triggers_image_update_without_cursor_motion)
++{
++    using namespace ::testing;
++
++    StubInputSurface surface{rect_1_1_1_1,
++        std::make_shared<NamedCursorImage>(cursor_name_1)};
++    StubInputTargets targets({mt::fake_shared(surface)});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++    {
++        InSequence seq;
++        EXPECT_CALL(cursor, show(CursorNamed(cursor_name_1))).Times(1);
++        EXPECT_CALL(cursor, show(CursorNamed(cursor_name_2))).Times(1);
++    }
++
++    controller.cursor_moved_to(1.0f, 1.0f);
++    surface.set_cursor_image(std::make_shared<NamedCursorImage>(cursor_name_2));
++}
++
++TEST_F(TestCursorController, change_in_scene_triggers_image_update)
++{
++    using namespace ::testing;
++
++    // Here we also demonstrate that the cursor begins at 0,0.
++    StubInputSurface surface{rect_0_0_1_1,
++        std::make_shared<NamedCursorImage>(cursor_name_1)};
++    StubInputTargets targets({});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++    EXPECT_CALL(cursor, show(CursorNamed(cursor_name_1))).Times(1);
++
++    targets.add_surface(mt::fake_shared(surface));
++}
++
++TEST_F(TestCursorController, cursor_image_not_reset_needlessly)
++{
++    using namespace ::testing;
++
++    auto image = std::make_shared<NamedCursorImage>(cursor_name_1);
++
++    // Here we also demonstrate that the cursor begins at 0,0.
++    StubInputSurface surface1{rect_0_0_1_1, image};
++    StubInputSurface surface2{rect_0_0_1_1, image};
++    StubInputTargets targets({});
++
++    mi::CursorController controller(mt::fake_shared(targets),
++        mt::fake_shared(cursor), default_cursor_image);
++
++    EXPECT_CALL(cursor, move_to(_)).Times(AnyNumber());
++    EXPECT_CALL(cursor, show(CursorNamed(cursor_name_1))).Times(1);
++
++    targets.add_surface(mt::fake_shared(surface1));
++    targets.add_surface(mt::fake_shared(surface2));
++}