Mir

Merge lp:~mir-team/mir/surface-output-events into lp:mir

surface-output-events
Merge into development-branch

Proposed by Chris Halse Rogers on 2015-09-29

Status:	Merged
Approved by:	Alexandros Frantzis on 2015-10-07
Approved revision:	3032
Merged at revision:	3000
Proposed branch:	lp:~mir-team/mir/surface-output-events
Merge into:	lp:mir
Prerequisite:	lp:~raof/mir/display-configuration-for-the-shell
Diff against target:	2661 lines (+1280/-110) 47 files modified include/client/mir/events/event_builders.h (+6/-0) include/client/mir_toolkit/events/event.h (+18/-0) include/client/mir_toolkit/events/surface_output_event.h (+61/-0) include/common/mir_toolkit/common.h (+14/-0) include/platform/mir/graphics/display_configuration.h (+13/-4) include/test/mir/test/doubles/stub_display_configuration.h (+51/-9) include/test/mir/test/empty_deleter.h (+1/-1) src/client/CMakeLists.txt (+1/-0) src/client/event.cpp (+27/-0) src/client/events/event_builders.cpp (+18/-0) src/client/rpc/mir_protobuf_rpc_channel.cpp (+3/-0) src/client/symbols.map (+4/-0) src/include/common/mir/events/event_private.h (+11/-0) src/include/server/mir/scene/surface_event_source.h (+10/-0) src/platform/graphics/display_configuration.cpp (+51/-13) src/platforms/android/server/fb_device.cpp (+3/-1) src/platforms/android/server/hwc_blanking_control.cpp (+7/-1) src/platforms/mesa/server/kms/real_kms_display_configuration.cpp (+5/-4) src/platforms/mesa/server/x11/graphics/display_configuration.cpp (+3/-1) src/server/graphics/nested/nested_display_configuration.cpp (+6/-2) src/server/graphics/offscreen/display_configuration.cpp (+3/-1) src/server/scene/CMakeLists.txt (+2/-0) src/server/scene/application_session.cpp (+31/-3) src/server/scene/application_session.h (+9/-0) src/server/scene/default_configuration.cpp (+4/-0) src/server/scene/output_properties_cache.cpp (+100/-0) src/server/scene/output_properties_cache.h (+66/-0) src/server/scene/session_manager.cpp (+15/-5) src/server/scene/session_manager.h (+18/-8) src/server/scene/surface_event_source.cpp (+20/-0) tests/acceptance-tests/test_client_focus_notification.cpp (+3/-0) tests/acceptance-tests/test_client_surface_events.cpp (+100/-0) tests/acceptance-tests/test_system_compositor_window_manager.cpp (+1/-3) tests/include/mir/test/doubles/stub_surface_factory.h (+5/-2) tests/integration-tests/session_management.cpp (+1/-1) tests/integration-tests/test_session.cpp (+2/-0) tests/mir_test/display_config_matchers.cpp (+6/-2) tests/unit-tests/graphics/mesa/kms/test_cursor.cpp (+9/-3) tests/unit-tests/graphics/mesa/kms/test_display_configuration.cpp (+34/-16) tests/unit-tests/graphics/test_default_display_configuration_policy.cpp (+4/-2) tests/unit-tests/graphics/test_display_configuration.cpp (+29/-1) tests/unit-tests/graphics/test_overlapping_output_grouping.cpp (+4/-2) tests/unit-tests/scene/test_abstract_shell.cpp (+9/-2) tests/unit-tests/scene/test_application_session.cpp (+466/-14) tests/unit-tests/scene/test_session_manager.cpp (+12/-3) tests/unit-tests/scene/test_surface.cpp (+5/-2) tests/unit-tests/scene/test_surface_impl.cpp (+9/-4)
To merge this branch:	bzr merge lp:~mir-team/mir/surface-output-events
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration	2015-09-29	Approve on 2015-10-07
Alexandros Frantzis (community)			Approve on 2015-10-07
Alan Griffiths		2015-09-29	Approve on 2015-10-06
Review via email: mp+272698@code.launchpad.net

This proposal supersedes a proposal from 2015-09-25.

Commit Message

send events pertaining to the output (dpi, form factor, scale) to the client, available as events.

Description of the Change

Send events pertaining to the output (dpi, form factor, scale) to the client, available as events.

Alan Griffiths (alan-griffiths) wrote on 2015-09-17: Posted in a previous version of this proposal

How much of this diff is the same as lp:~mir-team/mir/surface-event-ordering/+merge/270879

review: Needs Information

Kevin DuBois (kdub) wrote on 2015-09-17: Posted in a previous version of this proposal

let me figure that out and restack accordingly...

Kevin DuBois (kdub) wrote on 2015-09-17: Posted in a previous version of this proposal

@Alan, about half :)

Alan Griffiths (alan-griffiths) wrote on 2015-09-17: Posted in a previous version of this proposal

+ /// \return the display configuration changer
+ auto the_display_changer() const -> std::shared_ptr<mir::DisplayChanger>;

Why are we making internal wiring part of the API?

~~~~

+#include "src/include/server/mir/display_changer.h"

There's a reason src/include/server/ is not on the include path: Acceptance tests should only use the public API.

review: Needs Fixing

Alan Griffiths (alan-griffiths) wrote on 2015-09-17: Posted in a previous version of this proposal

> +#include "src/include/server/mir/display_changer.h"
>
> There's a reason src/include/server/ is not on the include path: Acceptance
> tests should only use the public API.

OK, maybe it's arguable that this already happens in some acceptance tests.

PS Jenkins bot (ps-jenkins) wrote on 2015-09-17: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-17: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Kevin DuBois (kdub) wrote on 2015-09-17: Posted in a previous version of this proposal

still have to find the fd leak in test, please still review :)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-18: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-09-18: Posted in a previous version of this proposal

display_changer.h is not (and should not be) a public header.

That means the API should not include:

+ /// \return the display configuration changer
+ auto the_display_changer() const -> std::shared_ptr<mir::DisplayChanger>;

as that isn't of any use to library users.

review: Needs Fixing

PS Jenkins bot (ps-jenkins) wrote on 2015-09-19: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-19: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-21: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:2974
http://jenkins.qa.ubuntu.com/job/mir-ci/4970/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4062/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2969/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4004/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1120/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4005/console

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-21: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:2975
http://jenkins.qa.ubuntu.com/job/mir-ci/4971/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4063/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2970/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4005/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1121/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4006/console

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-21: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:2976
http://jenkins.qa.ubuntu.com/job/mir-ci/4972/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4064/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2971/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4006/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1122/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4007/console

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

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-09-23: Posted in a previous version of this proposal

-)
+ ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/events/surface_output_event.h)

Not our usual placement of parentheses.

Chris Halse Rogers (raof) wrote on 2015-09-25: Posted in a previous version of this proposal

This is *mostly* ready to review. The exposure of DisplayChanger needs to be replaced by adding a subset of that interface to something in mir::scene and then rebasing on that.

PS Jenkins bot (ps-jenkins) wrote on 2015-09-25: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-29: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:3014
http://jenkins.qa.ubuntu.com/job/mir-ci/5054/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4170
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/3077
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4112/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-wily-touch/70/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1205
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1205/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/70/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4113
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4113/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/6794/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/23736
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-wily-armhf/71/console

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-09-29:

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

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-09-29:

MIR_CLIENT_9.2 { # New functions in Mir 0.16
global:
mir_surface_spec_set_event_handler;
+ mir_event_get_surface_output_event;
+ mir_surface_output_event_get_dpi;
+ mir_surface_output_event_get_form_factor;
+ mir_surface_output_event_get_scale;

0.16 has been branched. These should be in a 0.17 stanza

~~~~

+std::string as_string(MirFormFactor form_factor)
+{

Is there any good reason for std::string as opposed to char const*?

~~~~

+ out << "{" << std::endl << "\tid: " << val.id << std::endl << "\tcard_id: " << val.card_id << std::endl
+ << "\ttype: " << output_type_to_string(val.type) << std::endl
+ << "\tmodes: [ ";

We don't need all the flush() calls from the endl manipulator - "\n" would be fine.

~~~~

+ std::function<std::shared_ptr<graphics::DisplayConfiguration const>()> const& get_display_config,

I very much prefer defining an interface for the desired functionality over using std::function<>. Even when the interface has a single member function this makes the dependences across the system much clearer.

Instead of MediatingDisplayChanger implementing a DisplayConfigurationProvider interface, we have a std::function<> that wraps a call to a builder function to call a function on an interface required by frontend that coincidentally offers functionality also needed by the SessionManager.

~~~~

+ [this]() -> std::shared_ptr<mg::DisplayConfiguration>
+ {
+ return the_frontend_display_changer()->active_configuration();
+ },

I don't think this parameter should be a std::function<> (see previous note) but, given this approach, it ought to capture result of the_frontend_display_changer(), not the DefaultServerConfiguration. The reason being that the dependency is between SessionManager and a facility implemented by MediatingDisplayChanger and the latter should be kept alive, not (potentially) reconstructed for each request.

review: Needs Fixing

lp:~mir-team/mir/surface-output-events updated on 2015-09-30

2981. By Chris Halse Rogers on 2015-09-30

EventSinkFactory: Delete CopyAssign

2982. By Chris Halse Rogers on 2015-09-30

Drop changes to MockEventSink

2983. By Chris Halse Rogers on 2015-09-30

Add shell::DisplayConfigurationController.

This allows a shell to correctly change the display configuration, notifying clients
as appropriate.

2984. By Chris Halse Rogers on 2015-09-30

MediatingDisplayChanger: Implement ms::DisplayConfigurationController

2985. By Chris Halse Rogers on 2015-09-30

Augment mt::DisplayConfigMatches to handle the other client/server comparison order

2986. By Chris Halse Rogers on 2015-09-30

mtd::StubDisplayConfig: Add a constructor that duplicates an existing mg::DisplayConfig

2987. By Chris Halse Rogers on 2015-09-30

Expose mir::Server::the_display_configuration_controller().

Implemented by ms::MediatingDisplayChanger by default.

2988. By Chris Halse Rogers on 2015-09-30

Acceptance test for set_default_display_configuration()

Alan Griffiths (alan-griffiths) wrote on 2015-09-30:

"Diff against target: 0 lines"

Probably not as intended

review: Needs Information

lp:~mir-team/mir/surface-output-events updated on 2015-10-02

2989. By Chris Halse Rogers on 2015-10-01

DisplayConfigurationController: Delete CopyAssign

2990. By Chris Halse Rogers on 2015-10-02

First cut at mir_surface_output_event acceptance test

2991. By Chris Halse Rogers on 2015-10-02

Add DisplayConfigurationOutput unit-test for comparison with new fields

2992. By Chris Halse Rogers on 2015-10-02

StubDisplayConfig: Add a constructor taking a vector<DisplayConfigurationOutput>

2993. By Chris Halse Rogers on 2015-10-02

First go at pushing SurfaceOutputEvents from the ApplicationSession

2994. By Chris Halse Rogers on 2015-10-02

Send output properties appropriate to the display the top-left corner of a surface is on

2995. By Chris Halse Rogers on 2015-10-02

Send the details of the highest-scale output a surface is partially on

2996. By Chris Halse Rogers on 2015-10-02

Factor out an OutputPropertiesCache

2997. By Chris Halse Rogers on 2015-10-02

Make OutputPropertiesCache::properties_for resiliant under failure to set initial config

2998. By Chris Halse Rogers on 2015-10-02

Send SurfaceOutput event in response to moving a surface to a different output

2999. By Chris Halse Rogers on 2015-10-02

Give surface output events their own test fixture.

It's different enough from ApplicationSessionSender to make it worthwhile.

3000. By Chris Halse Rogers on 2015-10-02

Factor out test output configuration setup

3001. By Chris Halse Rogers on 2015-10-02

Add operator<<(ostream, DisplayConfiguration).

We've already got pretty-printers for DisplayConfigurationCard and DisplayConfigurationOutput,
let's go the whole hog.

3002. By Chris Halse Rogers on 2015-10-02

client: Dispatch mir_event_type_surface_output to the correct MirSurface

3003. By Chris Halse Rogers on 2015-10-02

Improve pretty-printing for DisplayConfigurationOutput

3004. By Chris Halse Rogers on 2015-10-02

Slighly generalise mt::EmptyDeleter.

It's fine to take a void const*, which I'll soon want to pass it.

3005. By Chris Halse Rogers on 2015-10-02

Plumb the initial display configuration through to ApplicationSession.

The next step is to have the application session use this to send a SurfaceOutputEvent
on surface creation.

3006. By Chris Halse Rogers on 2015-10-02

Pass a non-null sender in ApplicationSessionSurfaceOutput tests.

This lets them pass, rather than SEGV when they try to dereference it...

3007. By Kevin DuBois on 2015-10-02

improve the android code to return the right form factor for external displays

3008. By Kevin DuBois on 2015-10-02

get tests to compile, and pass

3009. By Kevin DuBois on 2015-10-02

correct a bit in OutputProperties cache to avoid atomics

3010. By Chris Halse Rogers on 2015-10-02

Add test for surface-output event on construction

3011. By Kevin DuBois on 2015-10-02

Ignore the new scaling event in the focus test

3012. By Kevin DuBois on 2015-10-02

correct the unit tests, which needed some mock behavior added

3013. By Kevin DuBois on 2015-10-02

correction for integration test, all tests passing

3014. By Kevin DuBois on 2015-10-02

clean up spacings where possible

3015. By Kevin DuBois on 2015-10-02

fix up clang

3016. By Chris Halse Rogers on 2015-10-02

Add mir_form_factor_unknown

3017. By Chris Halse Rogers on 2015-10-02

Fix CMakeLists.txt formatting

3018. By Chris Halse Rogers on 2015-10-02

Make SystemCompositorWindowManager.if_no_surface_posts_client_never_gets_focus resiliant to non-focus events being sent.

If a mock function has an EXPECT_CALL set for it, even if it's .Times(0), then any calls
that *don't* match that specifier become errors.

There's no reason to fail that test if the surface receives a non-focus event, and there's
no reason to add expectations for any other surface events we might choose to send now
or in the future.

3019. By Chris Halse Rogers on 2015-10-02

SessionManager: Take a reference to the_display() rather than a std::function<> to get the configuration.

3020. By Chris Halse Rogers on 2015-10-02

Add new client symbols to new version stanza; 0.17 is being released

3021. By Chris Halse Rogers on 2015-10-02

We don't need to construct a std::string to print the MirFormFactor

3022. By Chris Halse Rogers on 2015-10-02

Fewer superfluous flush() calls via std::endl

Chris Halse Rogers (raof) wrote on 2015-10-02:

> MIR_CLIENT_9.2 { # New functions in Mir 0.16
> global:
> mir_surface_spec_set_event_handler;
> + mir_event_get_surface_output_event;
> + mir_surface_output_event_get_dpi;
> + mir_surface_output_event_get_form_factor;
> + mir_surface_output_event_get_scale;
>
> 0.16 has been branched. These should be in a 0.17 stanza
>

Done.
> ~~~~
>
> +std::string as_string(MirFormFactor form_factor)
> +{
>
> Is there any good reason for std::string as opposed to char const*?
>

No; fixed.

> ~~~~
>
> + out << "{" << std::endl << "\tid: " << val.id << std::endl << "\tcard_id:
> " << val.card_id << std::endl
> + << "\ttype: " << output_type_to_string(val.type) << std::endl
> + << "\tmodes: [ ";
>
> We don't need all the flush() calls from the endl manipulator - "\n" would be
> fine.

But then we won't be portable to platforms that need \r\n! :)

Fixed.

Chris Halse Rogers (raof) wrote on 2015-10-02:

Done.
> ~~~~
>
> +std::string as_string(MirFormFactor form_factor)
> +{
>
> Is there any good reason for std::string as opposed to char const*?
>

No; fixed.

But then we won't be portable to platforms that need \r\n! :)

Fixed.

PS Jenkins bot (ps-jenkins) wrote on 2015-10-02:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-10-02:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-10-02:

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

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-10-02:

> > We don't need all the flush() calls from the endl manipulator - "\n" would
> be
> > fine.
>
> But then we won't be portable to platforms that need \r\n! :)

We'll be just as portable as with endl. (Which by definition is put(widen('\n')) followed by flush().)

Alan Griffiths (alan-griffiths) wrote on 2015-10-02:

+MIR_CLIENT_0.18 {
+ mir_event_get_surface_output_event;
+ mir_surface_output_event_get_dpi;
+ mir_surface_output_event_get_form_factor;
+ mir_surface_output_event_get_scale;
+} MIR_CLIENT_9v17;

We've not branched 0.17 yet - these should be in the 0.17 stanza.

review: Needs Fixing

lp:~mir-team/mir/surface-output-events updated on 2015-10-05

3023. By Chris Halse Rogers on 2015-10-05: Add new client symbols to correct version stanza

Chris Halse Rogers (raof) wrote on 2015-10-05:

See, this is why my DSO proposal has a _unreleased stanza :)

Fixed.

PS Jenkins bot (ps-jenkins) wrote on 2015-10-05:

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

review: Needs Fixing (continuous-integration)

lp:~mir-team/mir/surface-output-events updated on 2015-10-05

3024. By Chris Halse Rogers on 2015-10-05

OutputPropertiesCache: Correctly handle output.connected == false.

Disconnected outputs have an empty output.modes vector, and some of their fields
- such as current_mode_index - are uninitialised. Don't try to index into an empty
vector by an uninitialised index.

3025. By Chris Halse Rogers on 2015-10-05

Fix up mg::DisplayConfigurationOutput::*_mode_index.

Using size_t in the server doesn't make any sense when we send them over
the wire to clients as uint32_t.

3026. By Chris Halse Rogers on 2015-10-05

OutputPropertiesCache: Even more paranoia about outputs.

Really what we care about is that the current_mode_index is valid.
Just check against the size of the mode vector directly.

PS Jenkins bot (ps-jenkins) wrote on 2015-10-05:

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

review: Needs Fixing (continuous-integration)

Chris Halse Rogers (raof) wrote on 2015-10-05:

HOW DID THAT NOT FAIL LOCALLY?

lp:~mir-team/mir/surface-output-events updated on 2015-10-05

3027. By Chris Halse Rogers on 2015-10-05: Fix two build issues that *my* gcc-5 doesn't find for some reason

PS Jenkins bot (ps-jenkins) wrote on 2015-10-05:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-10-05:

FAILED: Continuous integration, rev:3027
http://jenkins.qa.ubuntu.com/job/mir-ci/5136/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4269
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/3176
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4211/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-wily-touch/169/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1290
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1290/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/169/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4212/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-wily-armhf/170/console

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-10-05:

FAILED: Continuous integration, rev:3027
http://jenkins.qa.ubuntu.com/job/mir-ci/5141/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/4275
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/3182
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/4217/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-wily-touch/175/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1295
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/1295/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-i386-ci/175/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/4218/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-wily-armhf/176/console

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

review: Needs Fixing (continuous-integration)

lp:~mir-team/mir/surface-output-events updated on 2015-10-06

3028. By Chris Halse Rogers on 2015-10-06

StubDisplayConfig: Ensure the first display is connected and used.

The Android tests assume that the first output of the StubDisplayConfig contains
sane values, which is not true for disconnected outputs.

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

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

review: Approve (continuous-integration)

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

There's a lot of superfluous flush() calls (from using endl).

review: Approve

Alexandros Frantzis (afrantzis) wrote on 2015-10-06:

A couple of concerns:

+ auto new_output_properties = outputs.properties_for(geom::Rectangle{top_left, {100,100}});
+ if (new_output_properties)

Unless I overlooked some logic, we will be sending unchanged output properties to the client on every move, flooding the clients unnecessarily. We shouldn't be sending output properties unless there is a change.

Is the 100x100 area we are using to decide on which output the surface belongs to based on some specification or is it completely arbitrary? In any case we should document this decision in the code (name and/or comment).

review: Needs Fixing

lp:~mir-team/mir/surface-output-events updated on 2015-10-07

3029. By Chris Halse Rogers on 2015-10-07: Factor out a SurfaceOutputEventFor matcher
3030. By Chris Halse Rogers on 2015-10-07: Drop some unsatisfying mockery
3031. By Chris Halse Rogers on 2015-10-07: SurfaceEventSource: Use the surface's actual size for output calculations.
3032. By Chris Halse Rogers on 2015-10-07: SurfaceEventSource: Only send SurfaceOutputEvents when the surface moves to a different output.

Chris Halse Rogers (raof) wrote on 2015-10-07:

> A couple of concerns:
>
> + auto new_output_properties =
> outputs.properties_for(geom::Rectangle{top_left, {100,100}});
> + if (new_output_properties)
>
> Unless I overlooked some logic, we will be sending unchanged output properties
> to the client on every move, flooding the clients unnecessarily. We shouldn't
> be sending output properties unless there is a change.
>
> Is the 100x100 area we are using to decide on which output the surface belongs
> to based on some specification or is it completely arbitrary? In any case we
> should document this decision in the code (name and/or comment).

Urgh, thanks for noticing. These were both artefacts of work half-finished before I needed to go back and hack some prerequisite. Fixed.

PS Jenkins bot (ps-jenkins) wrote on 2015-10-07:

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

review: Approve (continuous-integration)

Alexandros Frantzis (afrantzis) wrote on 2015-10-07:

Looks good.

review: Approve

PS Jenkins bot (ps-jenkins) on 2015-10-07:

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/events/event_builders.h'
 --- include/client/mir/events/event_builders.h	2015-09-16 17:20:32 +0000
 +++ include/client/mir/events/event_builders.h	2015-10-07 06:10:46 +0000
@@ -46,6 +46,12 @@
  EventUPtr make_event(frontend::SurfaceId const& surface_id);
  // Keymap event
  EventUPtr make_event(frontend::SurfaceId const& surface_id, xkb_rule_names const& names);
++// Surface output event
++EventUPtr make_event(
++    frontend::SurfaceId const& surface_id,
++    int dpi,
++    float scale,
++    MirFormFactor form_factor);
  // Key event
  EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
 === modified file 'include/client/mir_toolkit/events/event.h'
 --- include/client/mir_toolkit/events/event.h	2015-06-18 04:38:28 +0000
 +++ include/client/mir_toolkit/events/event.h	2015-10-07 06:10:46 +0000
@@ -45,6 +45,7 @@
      mir_event_type_input,
      mir_event_type_keymap,
      mir_event_type_input_configuration,
++    mir_event_type_surface_output,
  } MirEventType;
  typedef struct MirSurfaceEvent MirSurfaceEvent;
@@ -55,6 +56,7 @@
  typedef struct MirInputEvent MirInputEvent;
  typedef struct MirKeymapEvent MirKeymapEvent;
  typedef struct MirInputConfigurationEvent MirInputConfigurationEvent;
++typedef struct MirSurfaceOutputEvent MirSurfaceOutputEvent;
  typedef union MirEvent MirEvent;
@@ -70,6 +72,7 @@
  #include "mir_toolkit/events/prompt_session_event.h"
  #include "mir_toolkit/events/keymap_event.h"
  #include "mir_toolkit/events/input_configuration_event.h"
++#include "mir_toolkit/events/surface_output_event.h"
  #ifdef __cplusplus
  /**
@@ -169,6 +172,21 @@
   */
  MirInputConfigurationEvent const* mir_event_get_input_configuration_event(MirEvent const* ev);
++/**
++ * Retrieve the MirSurfaceOutputEvent associated with a MirEvent of type
++ * mir_event_type_surface_output. The event signifies that the properties
++ * of the output the surface is displayed upon have changed.
++ *
++ * A MirSurfaceOutputEvent is generated either when the properties of the
++ * output the surface is primarily on change (for example: by user configuration
++ * of resolution) or when the output the surface is primarily on changes
++ * (for example: when a user moves the surface from one monitor to another).
++ *
++ * \param [in] event The event
++ * \return           The associated MirSurfaceOutputEvent
++ */
++MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev);
++
  /*
+  *
   * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 === added file 'include/client/mir_toolkit/events/surface_output_event.h'
 --- include/client/mir_toolkit/events/surface_output_event.h	1970-01-01 00:00:00 +0000
 +++ include/client/mir_toolkit/events/surface_output_event.h	2015-10-07 06:10:46 +0000
@@ -0,0 +1,61 @@
++/*
++ * Copyright © 2015 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_TOOLKIT_SURFACE_OUTPUT_EVENT_H_
++#define MIR_TOOLKIT_SURFACE_OUTPUT_EVENT_H_
++
++#include <mir_toolkit/events/event.h>
++
++#ifdef __cplusplus
++/**
++ * \addtogroup mir_toolkit
++ * @{
++ */
++extern "C" {
++#endif
++
++/**
++ * Retrieve the DPI of the new output configuration of a MirSurfaceOutputEvent
++ *
++ * \param [in] ev   The event
++ * \return          The new DPI value for the surface is primarily on.
++ */
++int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev);
++
++/**
++ * Retrieve the form factor of the new output configuration of a MirSurfaceOutputEvent
++ *
++ * \param [in] ev   The event
++ * \return          The new form factor of the output the surface is primarily on.
++ */
++MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev);
++
++/**
++ * Retrieve the form factor of the new output configuration of a MirSurfaceOutputEvent
++ *
++ * \param [in] ev   The event
++ * \return          The new form factor of the output the surface is primarily on.
++ */
++float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev);
++
++#ifdef __cplusplus
++}
++/**@}*/
++#endif
++
++#endif //MIR_TOOLKIT_SURFACE_OUTPUT_EVENT_H_
 === modified file 'include/common/mir_toolkit/common.h'
 --- include/common/mir_toolkit/common.h	2015-09-18 12:07:07 +0000
 +++ include/common/mir_toolkit/common.h	2015-10-07 06:10:46 +0000
@@ -190,6 +190,20 @@
      mir_edge_attachment_any = mir_edge_attachment_vertical |
                                mir_edge_attachment_horizontal
  } MirEdgeAttachment;
++
++/**
++ * Form factor associated with a physical output
++ */
++typedef enum MirFormFactor
++{
++    mir_form_factor_unknown,
++    mir_form_factor_phone,
++    mir_form_factor_tablet,
++    mir_form_factor_monitor,
++    mir_form_factor_tv,
++    mir_form_factor_projector,
++} MirFormFactor;
++
  /**@}*/
  #endif
 === modified file 'include/platform/mir/graphics/display_configuration.h'
 --- include/platform/mir/graphics/display_configuration.h	2015-02-22 07:46:25 +0000
 +++ include/platform/mir/graphics/display_configuration.h	2015-10-07 06:10:46 +0000
@@ -93,7 +93,7 @@
      /** The modes supported by the output. */
      std::vector<DisplayConfigurationMode> modes;
      /** The index in the 'modes' vector of the preferred output mode. */
--    size_t preferred_mode_index;
++    uint32_t preferred_mode_index;
      /** The physical size of the output. */
      geometry::Size physical_size_mm;
      /** Whether the output is connected. */
@@ -103,13 +103,18 @@
      /** The top left point of this output in the virtual coordinate space. */
      geometry::Point top_left;
      /** The index in the 'modes' vector of the current output mode. */
--    size_t current_mode_index;
++    uint32_t current_mode_index;
      /** The current output pixel format. A matching entry should be found in the 'pixel_formats' vector*/
      MirPixelFormat current_format;
      /** Current power mode **/
      MirPowerMode power_mode;
      MirOrientation orientation;
++    /** Requested scale factor for this output, for HiDPI support */
++    float scale;
++    /** Form factor of this output; phone display, tablet, monitor, TV, projector... */
++    MirFormFactor form_factor;
++
      /** The logical rectangle occupied by the output, based on its position,
          current mode and orientation (rotation) */
      geometry::Rectangle extents() const;
@@ -127,15 +132,17 @@
      DisplayConfigurationOutputType const& type;
      std::vector<MirPixelFormat> const& pixel_formats;
      std::vector<DisplayConfigurationMode> const& modes;
--    size_t const& preferred_mode_index;
++    uint32_t const& preferred_mode_index;
      geometry::Size const& physical_size_mm;
      bool const& connected;
      bool& used;
      geometry::Point& top_left;
--    size_t& current_mode_index;
++    uint32_t& current_mode_index;
      MirPixelFormat& current_format;
      MirPowerMode& power_mode;
      MirOrientation& orientation;
++    float& scale;
++    MirFormFactor& form_factor;
      UserDisplayConfigurationOutput(DisplayConfigurationOutput& master);
      geometry::Rectangle extents() const;
@@ -174,6 +181,8 @@
      DisplayConfiguration& operator=(DisplayConfiguration const& c) = delete;
  };
++std::ostream& operator<<(std::ostream& out, DisplayConfiguration const& val);
++
+ }
+ }
 === modified file 'include/test/mir/test/doubles/stub_display_configuration.h'
 --- include/test/mir/test/doubles/stub_display_configuration.h	2015-09-30 07:19:48 +0000
 +++ include/test/mir/test/doubles/stub_display_configuration.h	2015-10-07 06:10:46 +0000
@@ -56,7 +56,9 @@
 ,
              format,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
+         }
+     {
+     }
@@ -119,6 +121,12 @@
+         {
              std::vector<graphics::DisplayConfigurationMode> modes;
++            // Every second output, starting with the first, is connected...
++            // (Android tests assume the first output in a configuration is connected)
++            auto const connected = [](int index) { return (index % 2) == 0; };
++            // ..and every second connected output is used...
++            auto const used = [](int index) { return (index % 4) == 0; };
++
              for (auto j = 0u; j <= i; j++)
+             {
                  geometry::Size sz{mode_index*4, mode_index*3};
@@ -127,21 +135,37 @@
                  modes.push_back(mode);
+             }
--            size_t mode_index = modes.size() - 1;
++            uint32_t current_mode_index;
++            uint32_t preferred_mode_index;
++            if (connected(i))
++            {
++                current_mode_index = modes.size() - 1;
++                preferred_mode_index = i;
++            }
++            else
++            {
++                current_mode_index = std::numeric_limits<uint32_t>::max();
++                preferred_mode_index = std::numeric_limits<uint32_t>::max();
++            }
++
              geometry::Size physical_size{};
              geometry::Point top_left{};
              graphics::DisplayConfigurationOutput output{
                  graphics::DisplayConfigurationOutputId{static_cast<int>(i + 1)},
                  graphics::DisplayConfigurationCardId{static_cast<int>(i)},
                  graphics::DisplayConfigurationOutputType::vga,
--                pfs, modes, i,
++                pfs,
++                connected(i) ? modes : std::vector<graphics::DisplayConfigurationMode>{},
++                preferred_mode_index,
                  physical_size,
--                ((i % 2) == 0),  // even numbers have connected==true
--                ((i % 4) == 0),  // only every second even has used==true
++                connected(i),
++                used(i),
                  top_left,
--                mode_index, pfs[0],
--                mir_power_mode_off,
--                mir_orientation_normal
++                current_mode_index, pfs[0],
++                used(i) ? mir_power_mode_on : mir_power_mode_off,
++                mir_orientation_normal,
++                1.0f,
++                mir_form_factor_monitor
              };
              outputs.push_back(output);
@@ -170,7 +194,9 @@
                  {{rect.size, 60.0}},
 , geometry::Size{}, true, true, rect.top_left, 0,
                  mir_pixel_format_abgr_8888, mir_power_mode_on,
--                mir_orientation_normal
++                mir_orientation_normal,
++                1.0f,
++                mir_form_factor_monitor
              };
              outputs.push_back(output);
@@ -185,6 +211,22 @@
          cards.push_back(card);
+     }
++    StubDisplayConfig(std::vector<graphics::DisplayConfigurationOutput> const& outputs)
++    {
++        graphics::DisplayConfigurationCard card{
++            graphics::DisplayConfigurationCardId{static_cast<int>(1)},
++            outputs.size()
++        };
++
++        cards.push_back(card);
++        this->outputs = outputs;
++
++        for (auto& output : this->outputs)
++        {
++            output.card_id = cards[0].id;
++        }
++    }
++
      void for_each_card(std::function<void(graphics::DisplayConfigurationCard const&)> f) const override
+     {
          for (auto const& card : cards)
 === modified file 'include/test/mir/test/empty_deleter.h'
 --- include/test/mir/test/empty_deleter.h	2015-06-22 03:04:56 +0000
 +++ include/test/mir/test/empty_deleter.h	2015-10-07 06:10:46 +0000
@@ -23,7 +23,7 @@
+ {
  struct EmptyDeleter
+ {
--    void operator()(void* )
++    void operator()(void const* )
+     {
+     }
  };
 === modified file 'src/client/CMakeLists.txt'
 --- src/client/CMakeLists.txt	2015-09-09 13:22:49 +0000
 +++ src/client/CMakeLists.txt	2015-10-07 06:10:46 +0000
@@ -72,6 +72,7 @@
    mir_buffer_stream_api.cpp
    default_client_buffer_stream_factory.cpp
    ${MIR_CLIENT_SOURCES}
++  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/events/surface_output_event.h
+ )
  # Ensure protobuf C++ headers have been produced before
 === modified file 'src/client/event.cpp'
 --- src/client/event.cpp	2015-06-17 05:20:42 +0000
 +++ src/client/event.cpp	2015-10-07 06:10:46 +0000
@@ -147,6 +147,13 @@
      return &ev->input_configuration;
+ }
++MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev)
++{
++    expect_event_type(ev, mir_event_type_surface_output);
++
++    return &ev->surface_output;
++}
++
  /* Surface event accessors */
  MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* ev)
@@ -221,6 +228,26 @@
      return ev->id;
+ }
++/* Surface output event accessors */
++
++int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev)
++{
++    expect_event_type(ev, mir_event_type_surface_output);
++    return ev->dpi;
++}
++
++MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev)
++{
++    expect_event_type(ev, mir_event_type_surface_output);
++    return ev->form_factor;
++}
++
++float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev)
++{
++    expect_event_type(ev, mir_event_type_surface_output);
++    return ev->scale;
++}
++
  // TODO: Until we opaquify the MirEvent structure and add
  // a ref count ref is implemented as copy.
  MirEvent const* mir_event_ref(MirEvent const* ev)
 === modified file 'src/client/events/event_builders.cpp'
 --- src/client/events/event_builders.cpp	2015-09-24 15:42:21 +0000
 +++ src/client/events/event_builders.cpp	2015-10-07 06:10:46 +0000
@@ -95,6 +95,24 @@
      return make_event_uptr(e);
+ }
++mir::EventUPtr mev::make_event(
++    mf::SurfaceId const& surface_id,
++    int dpi,
++    float scale,
++    MirFormFactor form_factor)
++{
++    auto e = new MirEvent;
++    memset(e, 0, sizeof(*e));
++
++    e->type = mir_event_type_surface_output;
++    e->surface_output.surface_id = surface_id.as_value();
++    e->surface_output.dpi = dpi;
++    e->surface_output.scale = scale;
++    e->surface_output.form_factor = form_factor;
++
++    return make_event_uptr(e);
++}
++
  namespace
+ {
  // Never exposed in old event, so lets avoid leaking it in to a header now.
 === modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
 --- src/client/rpc/mir_protobuf_rpc_channel.cpp	2015-09-17 20:32:32 +0000
 +++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2015-10-07 06:10:46 +0000
@@ -324,6 +324,9 @@
                  case mir_event_type_keymap:
                      surface_map->with_surface_do(mf::SurfaceId(e.keymap.surface_id), send_e);
                      break;
++                case mir_event_type_surface_output:
++                    surface_map->with_surface_do(mf::SurfaceId(e.surface_output.surface_id), send_e);
++                    break;
                  default:
                      event_sink->handle_event(e);
+                 }
 === modified file 'src/client/symbols.map'
 --- src/client/symbols.map	2015-09-21 11:31:49 +0000
 +++ src/client/symbols.map	2015-10-07 06:10:46 +0000
@@ -192,6 +192,10 @@
      mir_blob_release;
      mir_buffer_stream_set_scale;
      mir_buffer_stream_set_scale_sync;
++    mir_event_get_surface_output_event;
++    mir_surface_output_event_get_dpi;
++    mir_surface_output_event_get_form_factor;
++    mir_surface_output_event_get_scale;
  } MIR_CLIENT_9.2;
  MIR_CLIENT_DETAIL_9 {
 === modified file 'src/include/common/mir/events/event_private.h'
 --- src/include/common/mir/events/event_private.h	2015-08-17 18:33:38 +0000
 +++ src/include/common/mir/events/event_private.h	2015-10-07 06:10:46 +0000
@@ -164,6 +164,16 @@
      struct xkb_rule_names rules;
  };
++struct MirSurfaceOutputEvent
++{
++    MirEventType type;
++
++    int surface_id;
++    int dpi;
++    float scale;
++    MirFormFactor form_factor;
++};
++
  // Access to MirEvent is deprecated
  union MirEvent
+ {
@@ -177,6 +187,7 @@
      MirCloseSurfaceEvent   close_surface;
      MirKeymapEvent keymap;
      MirInputConfigurationEvent input_configuration;
++    MirSurfaceOutputEvent surface_output;
  };
  #ifdef __cplusplus
 === modified file 'src/include/server/mir/scene/surface_event_source.h'
 --- src/include/server/mir/scene/surface_event_source.h	2015-04-28 07:54:10 +0000
 +++ src/include/server/mir/scene/surface_event_source.h	2015-10-07 06:10:46 +0000
@@ -29,21 +29,31 @@
+ {
  namespace scene
+ {
++class Surface;
++class OutputProperties;
++class OutputPropertiesCache;
++
  class SurfaceEventSource : public NullSurfaceObserver
+ {
  public:
      SurfaceEventSource(
          frontend::SurfaceId id,
++        Surface const& surface,
++        OutputPropertiesCache const& outputs,
          std::shared_ptr<frontend::EventSink> const& event_sink);
      void attrib_changed(MirSurfaceAttrib attrib, int value) override;
      void resized_to(geometry::Size const& size) override;
++    void moved_to(geometry::Point const& top_left) override;
      void orientation_set_to(MirOrientation orientation) override;
      void client_surface_close_requested() override;
      void keymap_changed(xkb_rule_names const& names) override;
  private:
      frontend::SurfaceId const id;
++    Surface const& surface;
++    OutputPropertiesCache const& outputs;
++    std::weak_ptr<OutputProperties const> last_output;
      std::shared_ptr<frontend::EventSink> const event_sink;
  };
+ }
 === modified file 'src/platform/graphics/display_configuration.cpp'
 --- src/platform/graphics/display_configuration.cpp	2015-02-22 07:46:25 +0000
 +++ src/platform/graphics/display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -95,11 +95,33 @@
      return out << val.size.width << "x" << val.size.height << "@" << val.vrefresh_hz;
+ }
++namespace
++{
++char const* as_string(MirFormFactor form_factor)
++{
++    switch (form_factor)
++    {
++    case mir_form_factor_monitor:
++        return "monitor";
++    case mir_form_factor_projector:
++        return "projector";
++    case mir_form_factor_tv:
++        return "TV";
++    case mir_form_factor_phone:
++        return "phone";
++    case mir_form_factor_tablet:
++        return "tablet";
++    default:
++        return "UNKNOWN";
++    }
++}
++}
++
  std::ostream& mg::operator<<(std::ostream& out, mg::DisplayConfigurationOutput const& val)
+ {
--    out << "{ id: " << val.id << ", card_id: " << val.card_id
--        << " type: " << output_type_to_string(val.type)
--        << " modes: [";
++    out << "{\n\tid: " << val.id << "\n\tcard_id: " << val.card_id
++        << "\n\ttype: " << output_type_to_string(val.type)
++        << "\n\tmodes: [ ";
      for (size_t i = 0; i < val.modes.size(); ++i)
+     {
@@ -108,18 +130,30 @@
              out << ", ";
+     }
--    out << "], preferred_mode: " << val.preferred_mode_index;
--    out << " physical_size_mm: " << val.physical_size_mm.width << "x" << val.physical_size_mm.height;
--    out << ", connected: " << (val.connected ? "true" : "false");
--    out << ", used: " << (val.used ? "true" : "false");
--    out << ", top_left: " << val.top_left;
--    out << ", current_mode: " << val.current_mode_index << " (";
++    out << "]" << std::endl;
++    out << "\tpreferred_mode: " << val.preferred_mode_index << std::endl;
++    out << "\tphysical_size_mm: " << val.physical_size_mm.width << "x" << val.physical_size_mm.height << std::endl;
++    out << "\tconnected: " << (val.connected ? "true" : "false") << std::endl;
++    out << "\tused: " << (val.used ? "true" : "false") << std::endl;
++    out << "\ttop_left: " << val.top_left << std::endl;
++    out << "\tcurrent_mode: " << val.current_mode_index << " (";
      if (val.current_mode_index < val.modes.size())
          out << val.modes[val.current_mode_index];
      else
          out << "none";
--
--    out << ") }";
++    out << ")" << std::endl;
++
++    out << "\tscale: " << val.scale << std::endl;
++    out << "\tform factor: " << as_string(val.form_factor) << std::endl;
++    out << "}" << std::endl;
++
++    return out;
++}
++
++std::ostream& mg::operator<<(std::ostream& out, mg::DisplayConfiguration const& val)
++{
++    val.for_each_card([&out](auto card) { out << card << std::endl; });
++    val.for_each_output([&out](DisplayConfigurationOutput const& output) { out << output << std::endl; });
      return out;
+ }
@@ -163,7 +197,9 @@
                 (val1.top_left == val2.top_left) &&
                 (val1.orientation == val2.orientation) &&
                 (val1.current_mode_index == val2.current_mode_index) &&
--               (val1.modes.size() == val2.modes.size())};
++               (val1.modes.size() == val2.modes.size()) &&
++               (val1.scale == val2.scale) &&
++               (val1.form_factor == val2.form_factor)};
      if (equal)
+     {
@@ -259,7 +295,9 @@
          current_mode_index(master.current_mode_index),
          current_format(master.current_format),
          power_mode(master.power_mode),
--        orientation(master.orientation)
++        orientation(master.orientation),
++        scale(master.scale),
++        form_factor(master.form_factor)
+ {
+ }
 === modified file 'src/platforms/android/server/fb_device.cpp'
 --- src/platforms/android/server/fb_device.cpp	2015-09-17 20:32:32 +0000
 +++ src/platforms/android/server/fb_device.cpp	2015-10-07 06:10:46 +0000
@@ -73,7 +73,9 @@
 ,
          mga::to_mir_format(fb_device->format),
          mir_power_mode_on,
--        mir_orientation_normal
++        mir_orientation_normal,
++        1.0f,
++        mir_form_factor_phone
      };
+ }
 === modified file 'src/platforms/android/server/hwc_blanking_control.cpp'
 --- src/platforms/android/server/hwc_blanking_control.cpp	2015-07-21 04:30:03 +0000
 +++ src/platforms/android/server/hwc_blanking_control.cpp	2015-10-07 06:10:46 +0000
@@ -131,8 +131,12 @@
          external_modes.emplace_back(mg::DisplayConfigurationMode{pixel_size, vrefresh_hz});
      auto type = mg::DisplayConfigurationOutputType::lvds;
++    auto form_factor = mir_form_factor_phone;
      if (name == mga::DisplayName::external)
++    {
          type = mg::DisplayConfigurationOutputType::displayport;
++        form_factor = mir_form_factor_monitor;
++    }
      return {
          static_cast<mg::DisplayConfigurationOutputId>(name),
@@ -148,7 +152,9 @@
          preferred_format_index,
          display_format,
          external_mode,
--        mir_orientation_normal
++        mir_orientation_normal,
++        1.0f,
++        form_factor
      };
+ }
 === modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.cpp'
 --- src/platforms/mesa/server/kms/real_kms_display_configuration.cpp	2015-07-23 02:39:20 +0000
 +++ src/platforms/mesa/server/kms/real_kms_display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -171,9 +171,9 @@
          kms_connector_type_to_output_type(connector.connector_type)};
      geom::Size physical_size{connector.mmWidth, connector.mmHeight};
      bool connected{connector.connection == DRM_MODE_CONNECTED};
--    size_t const invalid_mode_index = std::numeric_limits<size_t>::max();
--    size_t current_mode_index{invalid_mode_index};
--    size_t preferred_mode_index{invalid_mode_index};
++    uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
++    uint32_t current_mode_index{invalid_mode_index};
++    uint32_t preferred_mode_index{invalid_mode_index};
      std::vector<DisplayConfigurationMode> modes;
      std::vector<MirPixelFormat> formats {mir_pixel_format_argb_8888,
                                           mir_pixel_format_xrgb_8888};
@@ -215,7 +215,8 @@
          outputs.push_back({id, card_id, type, formats, modes, preferred_mode_index,
                             physical_size, connected, false, geom::Point(),
                             current_mode_index, mir_pixel_format_xrgb_8888,
--                           mir_power_mode_on, mir_orientation_normal});
++                           mir_power_mode_on, mir_orientation_normal,
++                           1.0f, mir_form_factor_monitor});
+     }
      else
+     {
 === modified file 'src/platforms/mesa/server/x11/graphics/display_configuration.cpp'
 --- src/platforms/mesa/server/x11/graphics/display_configuration.cpp	2015-09-10 22:53:53 +0000
 +++ src/platforms/mesa/server/x11/graphics/display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -41,7 +41,9 @@
 ,
              pf,
              mir_power_mode_on,
--            orientation},
++            orientation,
++            1.0f,
++            mir_form_factor_monitor},
      card{mg::DisplayConfigurationCardId{0}, 1}
+ {
+ }
 === modified file 'src/server/graphics/nested/nested_display_configuration.cpp'
 --- src/server/graphics/nested/nested_display_configuration.cpp	2015-09-08 13:58:20 +0000
 +++ src/server/graphics/nested/nested_display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -79,7 +79,9 @@
                  mir_output.current_mode,
                  mir_output.current_format,
                  mir_output.power_mode,
--                mir_output.orientation
++                mir_output.orientation,
++                1.0f,
++                mir_form_factor_monitor
              };
              f(output);
@@ -133,7 +135,9 @@
                  mir_output.current_mode,
                  mir_output.current_format,
                  mir_output.power_mode,
--                mir_output.orientation
++                mir_output.orientation,
++                1.0f,
++                mir_form_factor_monitor
              };
              UserDisplayConfigurationOutput user(output);
 === modified file 'src/server/graphics/offscreen/display_configuration.cpp'
 --- src/server/graphics/offscreen/display_configuration.cpp	2015-02-22 07:46:25 +0000
 +++ src/server/graphics/offscreen/display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -34,7 +34,9 @@
 ,
                   mir_pixel_format_xrgb_8888,
                   mir_power_mode_on,
--                 mir_orientation_normal},
++                 mir_orientation_normal,
++                 1.0f,
++                 mir_form_factor_monitor},
            card{mg::DisplayConfigurationCardId{0}, 1}
+ {
+ }
 === modified file 'src/server/scene/CMakeLists.txt'
 --- src/server/scene/CMakeLists.txt	2015-09-15 17:13:45 +0000
 +++ src/server/scene/CMakeLists.txt	2015-10-07 06:10:46 +0000
@@ -30,4 +30,6 @@
    rendering_tracker.cpp
    default_coordinate_translator.cpp
    timeout_application_not_responding_detector.cpp
++  output_properties_cache.cpp
++  output_properties_cache.h
+ )
 === modified file 'src/server/scene/application_session.cpp'
 --- src/server/scene/application_session.cpp	2015-09-24 00:35:49 +0000
 +++ src/server/scene/application_session.cpp	2015-10-07 06:10:46 +0000
@@ -19,6 +19,7 @@
  #include "application_session.h"
  #include "snapshot_strategy.h"
  #include "default_session_container.h"
++#include "output_properties_cache.h"
  #include "mir/scene/surface.h"
  #include "mir/scene/surface_event_source.h"
@@ -53,6 +54,7 @@
      std::string const& session_name,
      std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
      std::shared_ptr<SessionListener> const& session_listener,
++    mg::DisplayConfiguration const& initial_config,
      std::shared_ptr<mf::EventSink> const& sink) :
      surface_coordinator(surface_coordinator),
      surface_factory(surface_factory),
@@ -65,6 +67,7 @@
      next_surface_id(0)
+ {
      assert(surface_coordinator);
++    output_cache.update_from(initial_config);
+ }
  ms::ApplicationSession::~ApplicationSession()
@@ -95,8 +98,6 @@
      if (params.parent_id.is_set())
          params.parent = checked_find(the_params.parent_id.value())->second;
--    auto const observer = std::make_shared<scene::SurfaceEventSource>(id, surface_sink);
--
      std::shared_ptr<compositor::BufferStream> buffer_stream;
      if (params.content_id.is_set())
+     {
@@ -108,7 +109,7 @@
                                                 params.pixel_format,
                                                 params.buffer_usage};
          buffer_stream = buffer_stream_factory->create_buffer_stream(
--            stream_id, event_sink, buffer_properties);
++            stream_id, surface_sink, buffer_properties);
+     }
      auto surface = surface_factory->create_surface(buffer_stream, params);
      surface_coordinator->add_surface(surface, params.depth, params.input_mode, this);
@@ -122,6 +123,11 @@
      if (params.input_shape.is_set())
          surface->set_input_region(params.input_shape.value());
++    auto const observer = std::make_shared<scene::SurfaceEventSource>(
++        id,
++        *surface,
++        output_cache,
++        surface_sink);
      surface->add_observer(observer);
+     {
@@ -130,6 +136,8 @@
          streams[stream_id] = buffer_stream;
+     }
++    observer->moved_to(surface->top_left());
++
      session_listener->surface_created(*this, surface);
      return id;
+ }
@@ -287,6 +295,26 @@
  void ms::ApplicationSession::send_display_config(mg::DisplayConfiguration const& info)
+ {
      event_sink->handle_display_config_change(info);
++
++    output_cache.update_from(info);
++
++    std::lock_guard<std::mutex> lock{surfaces_and_streams_mutex};
++    for (auto& surface : surfaces)
++    {
++        auto output_properties = output_cache.properties_for(geometry::Rectangle{
++            surface.second->top_left(),
++            surface.second->size()});
++
++        if (output_properties)
++        {
++            event_sink->handle_event(
++                *mev::make_event(
++                    surface.first,
++                    output_properties->dpi,
++                    output_properties->scale,
++                    output_properties->form_factor));
++        }
++    }
+ }
  void ms::ApplicationSession::set_lifecycle_state(MirLifecycleState state)
 === modified file 'src/server/scene/application_session.h'
 --- src/server/scene/application_session.h	2015-09-24 00:35:49 +0000
 +++ src/server/scene/application_session.h	2015-10-07 06:10:46 +0000
@@ -21,6 +21,8 @@
  #include "mir/scene/session.h"
++#include "output_properties_cache.h"
++
  #include <atomic>
  #include <map>
  #include <mutex>
@@ -32,6 +34,10 @@
  class EventSink;
+ }
  namespace compositor { class BufferStream; }
++namespace graphics
++{
++class DisplayConfiguration;
++}
  namespace scene
+ {
  class SessionListener;
@@ -52,6 +58,7 @@
          std::string const& session_name,
          std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
          std::shared_ptr<SessionListener> const& session_listener,
++        graphics::DisplayConfiguration const& initial_config,
          std::shared_ptr<frontend::EventSink> const& sink);
      ~ApplicationSession();
@@ -107,6 +114,8 @@
      std::atomic<int> next_surface_id;
++    OutputPropertiesCache output_cache;
++
      typedef std::map<frontend::SurfaceId, std::shared_ptr<Surface>> Surfaces;
      typedef std::map<frontend::BufferStreamId, std::shared_ptr<compositor::BufferStream>> Streams;
      Surfaces::const_iterator checked_find(frontend::SurfaceId id) const;
 === modified file 'src/server/scene/default_configuration.cpp'
 --- src/server/scene/default_configuration.cpp	2015-09-30 07:19:48 +0000
 +++ src/server/scene/default_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -42,11 +42,14 @@
  #include "timeout_application_not_responding_detector.h"
  #include "mir/options/program_option.h"
  #include "mir/options/default_configuration.h"
++#include "mir/graphics/display_configuration.h"
++#include "mir/frontend/display_changer.h"
  namespace mc = mir::compositor;
  namespace mf = mir::frontend;
  namespace mi = mir::input;
  namespace ms = mir::scene;
++namespace mg = mir::graphics;
  namespace msh = mir::shell;
  std::shared_ptr<ms::SurfaceStackModel>
@@ -178,6 +181,7 @@
                      the_snapshot_strategy(),
                      the_session_event_sink(),
                      the_session_listener(),
++                    the_display(),
                      the_application_not_responding_detector());
          });
+ }
 === added file 'src/server/scene/output_properties_cache.cpp'
 --- src/server/scene/output_properties_cache.cpp	1970-01-01 00:00:00 +0000
 +++ src/server/scene/output_properties_cache.cpp	2015-10-07 06:10:46 +0000
@@ -0,0 +1,100 @@
++/*
++ * Copyright © 2015 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "output_properties_cache.h"
++
++#include "mir/geometry/rectangle.h"
++#include "mir/graphics/display_configuration.h"
++
++#include <atomic>
++#include <cmath>
++
++namespace ms = mir::scene;
++namespace mg = mir::graphics;
++namespace geom = mir::geometry;
++
++namespace
++{
++int calculate_dpi(mir::geometry::Size const& resolution, mir::geometry::Size const& size)
++{
++    float constexpr mm_per_inch = 25.4f;
++
++    auto diagonal_mm = sqrt(size.height.as_int()*size.height.as_int()
++                            + size.width.as_int()*size.width.as_int());
++    auto diagonal_px = sqrt(resolution.height.as_int() * resolution.height.as_int()
++                            + resolution.width.as_int() * resolution.width.as_int());
++
++    return diagonal_px / diagonal_mm * mm_per_inch;
++}
++}
++
++void ms::OutputPropertiesCache::update_from(mg::DisplayConfiguration const &config)
++{
++    auto new_properties = std::make_shared<std::vector<OutputProperties>>();
++
++    config.for_each_output(
++        [&new_properties](auto output)
++        {
++            if (output.current_mode_index < output.modes.size())
++            {
++                auto const mode = output.modes[output.current_mode_index];
++                new_properties->emplace_back(OutputProperties {
++                    output.extents(),
++                    calculate_dpi(mode.size, output.physical_size_mm),
++                    output.scale,
++                    output.form_factor});
++            }
++        });
++
++    std::lock_guard<std::mutex> lk(mutex);
++    cache = new_properties;
++}
++
++auto ms::OutputPropertiesCache::get_cache() const
++    -> std::shared_ptr<std::vector<OutputProperties>>
++{
++    std::lock_guard<std::mutex> lk(mutex);
++    return cache;
++}
++
++auto ms::OutputPropertiesCache::properties_for(geom::Rectangle const& extents) const
++    -> std::shared_ptr<OutputProperties const>
++{
++    auto temp_properties = get_cache();
++
++    std::shared_ptr<OutputProperties const> matching_output_properties{};
++    if (temp_properties)
++    {
++        for (auto const &output : *temp_properties)
++        {
++            if (output.extents.overlaps(extents))
++            {
++                if (!matching_output_properties ||
++                    (output.scale > matching_output_properties->scale))
++                {
++                    matching_output_properties = std::shared_ptr<OutputProperties const>(
++                        temp_properties,
++                        &output
++                    );
++                }
++            }
++        }
++    }
++
++    return matching_output_properties;
++}
 === added file 'src/server/scene/output_properties_cache.h'
 --- src/server/scene/output_properties_cache.h	1970-01-01 00:00:00 +0000
 +++ src/server/scene/output_properties_cache.h	2015-10-07 06:10:46 +0000
@@ -0,0 +1,66 @@
++/*
++ * Copyright © 2015 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_SCENE_OUTPUT_PROPERTIES_CACHE_H_
++#define MIR_SCENE_OUTPUT_PROPERTIES_CACHE_H_
++
++#include "mir_toolkit/common.h"
++#include "mir/geometry/rectangle.h"
++
++#include <vector>
++#include <memory>
++#include <mutex>
++
++namespace mir
++{
++namespace graphics
++{
++class DisplayConfiguration;
++}
++
++namespace scene
++{
++struct OutputProperties
++{
++    geometry::Rectangle extents;
++    int dpi;
++    float scale;
++    MirFormFactor form_factor;
++};
++
++class OutputPropertiesCache
++{
++public:
++
++    void update_from(graphics::DisplayConfiguration const& config);
++
++    std::shared_ptr<OutputProperties const> properties_for(geometry::Rectangle const& extents) const;
++
++private:
++    std::shared_ptr<std::vector<OutputProperties>> get_cache() const;
++
++    std::mutex mutable mutex;
++    std::shared_ptr<std::vector<OutputProperties>> cache;
++};
++
++}
++}
++
++
++
++#endif //MIR_SCENE_OUTPUT_PROPERTIES_CACHE_H_
 === modified file 'src/server/scene/session_manager.cpp'
 --- src/server/scene/session_manager.cpp	2015-06-18 04:38:28 +0000
 +++ src/server/scene/session_manager.cpp	2015-10-07 06:10:46 +0000
@@ -27,6 +27,8 @@
  #include "mir/scene/application_not_responding_detector.h"
  #include "session_event_sink.h"
  #include "mir/frontend/event_sink.h"
++#include "mir/graphics/display.h"
++#include "mir/graphics/display_configuration.h"
  #include <boost/throw_exception.hpp>
@@ -37,6 +39,7 @@
  namespace mf = mir::frontend;
  namespace ms = mir::scene;
++namespace mg = mir::graphics;
  namespace msh = mir::shell;
  ms::SessionManager::SessionManager(
@@ -47,6 +50,7 @@
      std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
      std::shared_ptr<SessionEventSink> const& session_event_sink,
      std::shared_ptr<SessionListener> const& session_listener,
++    std::shared_ptr<graphics::Display const> const& display,
      std::shared_ptr<ApplicationNotRespondingDetector> const& anr_detector) :
      surface_coordinator(surface_coordinator),
      surface_factory(surface_factory),
@@ -55,6 +59,7 @@
      snapshot_strategy(snapshot_strategy),
      session_event_sink(session_event_sink),
      session_listener(session_listener),
++    display{display},
      anr_detector{anr_detector}
+ {
+ }
@@ -84,11 +89,16 @@
      std::string const& name,
      std::shared_ptr<mf::EventSink> const& sender)
+ {
--    std::shared_ptr<Session> new_session =
--        std::make_shared<ApplicationSession>(
--            surface_coordinator, surface_factory,
--            buffer_stream_factory, client_pid, name,
--            snapshot_strategy, session_listener, sender);
++    std::shared_ptr<Session> new_session = std::make_shared<ApplicationSession>(
++            surface_coordinator,
++            surface_factory,
++            buffer_stream_factory,
++            client_pid,
++            name,
++            snapshot_strategy,
++            session_listener,
++            *display->configuration(),
++            sender);
      app_container->insert_session(new_session);
 === modified file 'src/server/scene/session_manager.h'
 --- src/server/scene/session_manager.h	2015-06-18 04:38:28 +0000
 +++ src/server/scene/session_manager.h	2015-10-07 06:10:46 +0000
@@ -26,6 +26,12 @@
  namespace mir
+ {
++namespace graphics
++{
++class DisplayConfiguration;
++class Display;
++}
++
  namespace scene
+ {
  class SessionContainer;
@@ -41,14 +47,17 @@
  class SessionManager : public SessionCoordinator
+ {
  public:
--    explicit SessionManager(std::shared_ptr<SurfaceCoordinator> const& surface_coordinator,
--                            std::shared_ptr<SurfaceFactory> const& surface_factory,
--                            std::shared_ptr<BufferStreamFactory> const& buffer_stream_factory,
--                            std::shared_ptr<SessionContainer> const& app_container,
--                            std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
--                            std::shared_ptr<SessionEventSink> const& session_event_sink,
--                            std::shared_ptr<SessionListener> const& session_listener,
--                            std::shared_ptr<ApplicationNotRespondingDetector> const& anr_detector);
++    SessionManager(
++        std::shared_ptr<SurfaceCoordinator> const& surface_coordinator,
++        std::shared_ptr<SurfaceFactory> const& surface_factory,
++        std::shared_ptr<BufferStreamFactory> const& buffer_stream_factory,
++        std::shared_ptr<SessionContainer> const& app_container,
++        std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
++        std::shared_ptr<SessionEventSink> const& session_event_sink,
++        std::shared_ptr<SessionListener> const& session_listener,
++        std::shared_ptr<graphics::Display const> const& display,
++        std::shared_ptr<ApplicationNotRespondingDetector> const& anr_detector);
++
      virtual ~SessionManager() noexcept;
      std::shared_ptr<Session> open_session(
@@ -75,6 +84,7 @@
      std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
      std::shared_ptr<SessionEventSink> const session_event_sink;
      std::shared_ptr<SessionListener> const session_listener;
++    std::shared_ptr<graphics::Display const> const display;
      std::shared_ptr<ApplicationNotRespondingDetector> const anr_detector;
  };
 === modified file 'src/server/scene/surface_event_source.cpp'
 --- src/server/scene/surface_event_source.cpp	2015-04-28 07:54:10 +0000
 +++ src/server/scene/surface_event_source.cpp	2015-10-07 06:10:46 +0000
@@ -18,8 +18,11 @@
  #include "mir/events/event_builders.h"
  #include "mir/scene/surface_event_source.h"
++#include "mir/scene/surface.h"
++#include "output_properties_cache.h"
  #include "mir/geometry/size.h"
++#include "mir/geometry/rectangle.h"
  #include <cstring>
  #include <algorithm>
@@ -30,8 +33,12 @@
  ms::SurfaceEventSource::SurfaceEventSource(
      frontend::SurfaceId id,
++    Surface const& surface,
++    OutputPropertiesCache const& outputs,
      std::shared_ptr<frontend::EventSink> const& event_sink) :
      id(id),
++    surface{surface},
++    outputs{outputs},
      event_sink(event_sink)
+ {
+ }
@@ -41,6 +48,19 @@
      event_sink->handle_event(*mev::make_event(id, size));
+ }
++void ms::SurfaceEventSource::moved_to(geom::Point const& top_left)
++{
++    auto new_output_properties = outputs.properties_for(geom::Rectangle{top_left, surface.size()});
++    if (new_output_properties && (new_output_properties != last_output.lock()))
++    {
++        event_sink->handle_event(*mev::make_event(
++            id,
++            new_output_properties->dpi,
++            new_output_properties->scale,
++            new_output_properties->form_factor));
++        last_output = new_output_properties;
++    }
++}
  void ms::SurfaceEventSource::attrib_changed(MirSurfaceAttrib attrib, int value)
+ {
 === modified file 'tests/acceptance-tests/test_client_focus_notification.cpp'
 --- tests/acceptance-tests/test_client_focus_notification.cpp	2015-07-27 10:26:01 +0000
 +++ tests/acceptance-tests/test_client_focus_notification.cpp	2015-10-07 06:10:46 +0000
@@ -95,6 +95,7 @@
      run_in_client([&]
+         {
              InSequence s;
++            EXPECT_CALL(observer, see(_)); //ignore scaling events
              EXPECT_CALL(observer, see(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused))).Times(1)
                  .WillOnce(mt::WakeUp(&all_events_received));
              // We may not see mir_surface_unfocused before connection closes
@@ -123,6 +124,7 @@
      auto const client_one = new_client_process([&]
+         {
              InSequence seq;
++            EXPECT_CALL(observer, see(_)); //ignore scaling events
              // We should receive focus as we are created
              EXPECT_CALL(observer, see(mt::SurfaceEvent(mir_surface_attrib_focus,
                  mir_surface_focused))).Times(1)
@@ -146,6 +148,7 @@
              client_one->detach();
              ready_for_second_client.wait_for_signal_ready_for();
++            EXPECT_CALL(observer, see(_)); //ignore scaling events
              EXPECT_CALL(observer, see(
                  mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))
                      .Times(1).WillOnce(mt::WakeUp(&all_events_received));
 === modified file 'tests/acceptance-tests/test_client_surface_events.cpp'
 --- tests/acceptance-tests/test_client_surface_events.cpp	2015-09-24 00:44:01 +0000
 +++ tests/acceptance-tests/test_client_surface_events.cpp	2015-10-07 06:10:46 +0000
@@ -21,6 +21,10 @@
  #include "mir/scene/surface.h"
  #include "mir/scene/surface_creation_parameters.h"
++#include "mir/graphics/display.h"
++
++#include "mir/shell/display_configuration_controller.h"
++
  #include "mir/test/event_matchers.h"
  #include "mir/test/doubles/wrap_shell_to_track_latest_surface.h"
  #include "mir_test_framework/connected_client_with_a_surface.h"
@@ -40,6 +44,7 @@
  namespace mt = mir::test;
  namespace mtd = mir::test::doubles;
  namespace mtf = mir_test_framework;
++namespace mg = mir::graphics;
  using namespace testing;
@@ -254,6 +259,39 @@
+     }
+ }
++TEST_F(ClientSurfaceEvents, surface_receives_output_event_when_configuration_changes)
++{
++    using namespace std::literals::chrono_literals;
++
++    auto constexpr form_factor = mir_form_factor_tablet;
++    float constexpr scale = 2.15f;
++
++    auto display_configuration = server.the_display()->configuration();
++
++    display_configuration->for_each_output(
++        [](mg::UserDisplayConfigurationOutput& output_config)
++        {
++            output_config.scale = scale;
++            output_config.form_factor = form_factor;
++        });
++
++    set_event_filter(mir_event_type_surface_output);
++    reset_last_event();
++
++    auto display_controller = server.the_display_configuration_controller();
++    display_controller->set_default_display_configuration(std::move(display_configuration)).get();
++
++    ASSERT_TRUE(wait_for_event(1min));
++
++    std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
++
++    EXPECT_THAT(mir_event_get_type(last_event), Eq(mir_event_type_surface_output));
++    auto output_event = mir_event_get_surface_output_event(last_event);
++
++    EXPECT_THAT(mir_surface_output_event_get_form_factor(output_event), Eq(form_factor));
++    EXPECT_THAT(mir_surface_output_event_get_scale(output_event), FloatEq(scale));
++}
++
  namespace
+ {
  class WrapShellGeneratingCloseEvent : public mir::shell::ShellWrapper
@@ -317,3 +355,65 @@
      mir_surface_release_sync(surface);
+ }
++
++struct EventContext
++{
++    EventContext()
++        : event{nullptr}
++    {
++    }
++
++    ~EventContext()
++    {
++        if (event != nullptr)
++            mir_event_unref(event);
++    }
++
++    mt::Signal captured;
++    MirEvent const* event;
++};
++
++void surface_output_capturing_callback(MirSurface*, MirEvent const* ev, void* ctx)
++{
++    if (mir_event_get_type(ev) == mir_event_type_surface_output)
++    {
++        auto out_event = reinterpret_cast<EventContext*>(ctx);
++        out_event->event = mir_event_ref(ev);
++        out_event->captured.raise();
++    }
++}
++
++TEST_F(ClientSurfaceEvents, surface_receives_output_event_on_creation)
++{
++    using namespace std::literals::chrono_literals;
++
++    auto constexpr form_factor = mir_form_factor_tablet;
++    float constexpr scale = 2.15f;
++
++    std::shared_ptr<mg::DisplayConfiguration> display_configuration{server.the_display()->configuration()};
++
++    display_configuration->for_each_output(
++        [](mg::UserDisplayConfigurationOutput& output_config)
++        {
++            output_config.scale = scale;
++            output_config.form_factor = form_factor;
++        });
++
++    auto display_controller = server.the_display_configuration_controller();
++    display_controller->set_default_display_configuration(std::move(display_configuration)).get();
++
++    EventContext context;
++
++    auto spec = mir_connection_create_spec_for_normal_surface(connection, 640, 480, mir_pixel_format_abgr_8888);
++    mir_surface_spec_set_event_handler(spec, &surface_output_capturing_callback, &context);
++    auto surface = mir_surface_create_sync(spec);
++    mir_surface_spec_release(spec);
++
++    ASSERT_TRUE(context.captured.wait_for(10s));
++    ASSERT_THAT(mir_event_get_type(context.event), Eq(mir_event_type_surface_output));
++    auto surface_event = mir_event_get_surface_output_event(context.event);
++    EXPECT_THAT(mir_surface_output_event_get_form_factor(surface_event), Eq(form_factor));
++    EXPECT_THAT(mir_surface_output_event_get_scale(surface_event), Eq(scale));
++
++    mir_surface_release_sync(surface);
++}
 === modified file 'tests/acceptance-tests/test_system_compositor_window_manager.cpp'
 --- tests/acceptance-tests/test_system_compositor_window_manager.cpp	2015-06-25 03:00:08 +0000
 +++ tests/acceptance-tests/test_system_compositor_window_manager.cpp	2015-10-07 06:10:46 +0000
@@ -199,7 +199,5 @@
      ON_CALL(client, surface_event(_, MirFocusEvent(mir_surface_focused)))
              .WillByDefault(InvokeWithoutArgs([&] { signal.raise(); }));
--    EXPECT_CALL(client, surface_event(_, MirFocusEvent(mir_surface_focused))).Times(0);
--
--    signal.wait_for(100ms);
++    EXPECT_FALSE(signal.wait_for(100ms)) << "Unexpected surface_focused event received";
+ }
 === modified file 'tests/include/mir/test/doubles/stub_surface_factory.h'
 --- tests/include/mir/test/doubles/stub_surface_factory.h	2015-06-25 03:00:08 +0000
 +++ tests/include/mir/test/doubles/stub_surface_factory.h	2015-10-07 06:10:46 +0000
@@ -35,9 +35,12 @@
  public:
      std::shared_ptr<scene::Surface> create_surface(
          std::shared_ptr<compositor::BufferStream> const&,
--        scene::SurfaceCreationParameters const&) override
++        scene::SurfaceCreationParameters const& params) override
+     {
--        return std::make_shared<testing::NiceMock<MockSurface>>();
++        using namespace testing;
++        auto surface = std::make_shared<NiceMock<MockSurface>>();
++        ON_CALL(*surface, size()).WillByDefault(Return(params.size));
++        return surface;;
+     }
  };
 === modified file 'tests/integration-tests/session_management.cpp'
 --- tests/integration-tests/session_management.cpp	2015-09-24 00:35:49 +0000
 +++ tests/integration-tests/session_management.cpp	2015-10-07 06:10:46 +0000
@@ -120,5 +120,5 @@
      auto const session = session_manager->open_session(0, __PRETTY_FUNCTION__, event_sink);
      EXPECT_CALL(*test_surface_stack, add_surface(_,_,_)).Times(1);
--    session_manager->create_surface(session, params, nullptr);
++    session_manager->create_surface(session, params, event_sink);
+ }
 === modified file 'tests/integration-tests/test_session.cpp'
 --- tests/integration-tests/test_session.cpp	2015-09-24 00:35:49 +0000
 +++ tests/integration-tests/test_session.cpp	2015-10-07 06:10:46 +0000
@@ -37,6 +37,7 @@
  #include "mir/test/doubles/stub_renderer.h"
  #include "mir/test/doubles/stub_surface_factory.h"
  #include "mir/test/doubles/null_pixel_buffer.h"
++#include "mir/test/doubles/stub_display_configuration.h"
  #include "mir_test_framework/stubbed_server_configuration.h"
  #include <gtest/gtest.h>
@@ -122,6 +123,7 @@
          "stress",
          conf.the_snapshot_strategy(),
          std::make_shared<ms::NullSessionListener>(),
++        mtd::StubDisplayConfig{},
          std::make_shared<mtd::NullEventSink>()
      };
      session.create_surface(ms::a_surface(), std::make_shared<mtd::NullEventSink>());
 === modified file 'tests/mir_test/display_config_matchers.cpp'
 --- tests/mir_test/display_config_matchers.cpp	2015-09-30 07:19:48 +0000
 +++ tests/mir_test/display_config_matchers.cpp	2015-10-07 06:10:46 +0000
@@ -69,7 +69,9 @@
                  protobuf_output.current_mode(),
                  static_cast<MirPixelFormat>(protobuf_output.current_format()),
                  static_cast<MirPowerMode>(protobuf_output.power_mode()),
--                static_cast<MirOrientation>(protobuf_output.orientation())
++                static_cast<MirOrientation>(protobuf_output.orientation()),
++                1.0f,
++                mir_form_factor_monitor
              };
              /* Modes */
@@ -135,7 +137,9 @@
                  client_output.current_mode,
                  client_output.current_format,
                  static_cast<MirPowerMode>(client_output.power_mode),
--                static_cast<MirOrientation>(client_output.orientation)
++                static_cast<MirOrientation>(client_output.orientation),
++                1.0f,
++                mir_form_factor_monitor
              };
              /* Modes */
 === modified file 'tests/unit-tests/graphics/mesa/kms/test_cursor.cpp'
 --- tests/unit-tests/graphics/mesa/kms/test_cursor.cpp	2015-07-23 02:39:20 +0000
 +++ tests/unit-tests/graphics/mesa/kms/test_cursor.cpp	2015-10-07 06:10:46 +0000
@@ -98,7 +98,9 @@
 ,
                  mir_pixel_format_invalid,
                  mir_power_mode_on,
--                mir_orientation_normal
++                mir_orientation_normal,
++                1.0f,
++                mir_form_factor_monitor
              });
          outputs.push_back(
+             {
@@ -118,7 +120,9 @@
 ,
                  mir_pixel_format_invalid,
                  mir_power_mode_on,
--                mir_orientation_normal
++                mir_orientation_normal,
++                1.0f,
++                mir_form_factor_monitor
              });
          outputs.push_back(
+             {
@@ -138,7 +142,9 @@
 ,
                  mir_pixel_format_invalid,
                  mir_power_mode_on,
--                mir_orientation_right
++                mir_orientation_right,
++                1.0f,
++                mir_form_factor_monitor
              });
+     }
 === modified file 'tests/unit-tests/graphics/mesa/kms/test_display_configuration.cpp'
 --- tests/unit-tests/graphics/mesa/kms/test_display_configuration.cpp	2015-10-05 17:36:04 +0000
 +++ tests/unit-tests/graphics/mesa/kms/test_display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -203,7 +203,9 @@
 ,
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
+         {
              mg::DisplayConfigurationOutputId{connector1_id},
@@ -211,15 +213,17 @@
              mg::DisplayConfigurationOutputType::unknown,
              {},
              std::vector<mg::DisplayConfigurationMode>(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              connector1_physical_size_mm,
              false,
              false,
              geom::Point(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
+         {
              mg::DisplayConfigurationOutputId{connector2_id},
@@ -227,15 +231,17 @@
              mg::DisplayConfigurationOutputType::edp,
              {},
              std::vector<mg::DisplayConfigurationMode>(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              connector2_physical_size_mm,
              false,
              false,
              geom::Point(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
+         }
      };
@@ -390,7 +396,9 @@
 ,
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
+         {
              mg::DisplayConfigurationOutputId(connector_ids[1]),
@@ -398,15 +406,17 @@
              mg::DisplayConfigurationOutputType::vga,
              {},
              std::vector<mg::DisplayConfigurationMode>(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              connector_physical_sizes_mm_before[1],
              false,
              false,
              geom::Point(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
      };
@@ -418,7 +428,7 @@
              mg::DisplayConfigurationOutputType::composite,
              {},
              std::vector<mg::DisplayConfigurationMode>(),
--            std::numeric_limits<size_t>::max(),
++            std::numeric_limits<uint32_t>::max(),
              connector_physical_sizes_mm_after[0],
              false,
              true,
@@ -426,7 +436,9 @@
 ,  // Ensure current_mode_index is remembered even still
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
+         {
              mg::DisplayConfigurationOutputId(connector_ids[1]),
@@ -442,7 +454,9 @@
 ,
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
      };
@@ -562,7 +576,9 @@
 ,
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
      };
@@ -583,7 +599,9 @@
                  // available modes has also changed
              mir_pixel_format_invalid,
              mir_power_mode_on,
--            mir_orientation_normal
++            mir_orientation_normal,
++            1.0f,
++            mir_form_factor_monitor
          },
      };
 === modified file 'tests/unit-tests/graphics/test_default_display_configuration_policy.cpp'
 --- tests/unit-tests/graphics/test_default_display_configuration_policy.cpp	2015-06-25 14:21:36 +0000
 +++ tests/unit-tests/graphics/test_default_display_configuration_policy.cpp	2015-10-07 06:10:46 +0000
@@ -93,7 +93,9 @@
 ,
          mir_pixel_format_abgr_8888,
          mir_power_mode_on,
--        mir_orientation_normal
++        mir_orientation_normal,
++        1.0f,
++        mir_form_factor_monitor
      };
+ }
@@ -116,7 +118,7 @@
      output.pixel_formats = {};
      output.modes = {};
      output.current_format = mir_pixel_format_invalid;
--    output.current_mode_index = std::numeric_limits<size_t>::max();
++    output.current_mode_index = std::numeric_limits<uint32_t>::max();
      return output;
+ }
 === modified file 'tests/unit-tests/graphics/test_display_configuration.cpp'
 --- tests/unit-tests/graphics/test_display_configuration.cpp	2015-02-22 07:46:25 +0000
 +++ tests/unit-tests/graphics/test_display_configuration.cpp	2015-10-07 06:10:46 +0000
@@ -47,7 +47,9 @@
 ,
      mir_pixel_format_abgr_8888,
      mir_power_mode_on,
--    mir_orientation_normal
++    mir_orientation_normal,
++    1.0f,
++    mir_form_factor_monitor
  };
+ }
@@ -244,6 +246,32 @@
      EXPECT_EQ(b, a);
+ }
++TEST(DisplayConfiguration, outputs_with_different_scaling_factors_compare_unequal)
++{
++    mg::DisplayConfigurationOutput a = tmpl_output;
++    mg::DisplayConfigurationOutput b = tmpl_output;
++
++    EXPECT_EQ(a, b);
++    EXPECT_EQ(b, a);
++    a.scale = 2.0f;
++    b.scale = 3.0f;
++    EXPECT_NE(a, b);
++    EXPECT_NE(b, a);
++}
++
++TEST(DisplayConfiguration, outputs_with_different_form_factors_compare_unequal)
++{
++    mg::DisplayConfigurationOutput a = tmpl_output;
++    mg::DisplayConfigurationOutput b = tmpl_output;
++
++    EXPECT_EQ(a, b);
++    EXPECT_EQ(b, a);
++    a.form_factor = mir_form_factor_monitor;
++    b.form_factor = mir_form_factor_projector;
++    EXPECT_NE(a, b);
++    EXPECT_NE(b, a);
++}
++
  TEST(DisplayConfiguration, output_extents_uses_current_mode)
+ {
      mg::DisplayConfigurationOutput out = tmpl_output;
 === modified file 'tests/unit-tests/graphics/test_overlapping_output_grouping.cpp'
 --- tests/unit-tests/graphics/test_overlapping_output_grouping.cpp	2015-02-22 07:46:25 +0000
 +++ tests/unit-tests/graphics/test_overlapping_output_grouping.cpp	2015-10-07 06:10:46 +0000
@@ -73,7 +73,7 @@
      void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
+     {
--        size_t i = 1;
++        uint32_t i = 1;
          for (auto const& info : outputs)
+         {
              std::vector<mg::DisplayConfigurationMode> modes(i);
@@ -94,7 +94,9 @@
                  i - 1,
                  mir_pixel_format_invalid,
                  info.power_mode,
--                info.orientation
++                info.orientation,
++                1.0f,
++                mir_form_factor_monitor
              };
              f(output);
 === modified file 'tests/unit-tests/scene/test_abstract_shell.cpp'
 --- tests/unit-tests/scene/test_abstract_shell.cpp	2015-09-24 00:35:49 +0000
 +++ tests/unit-tests/scene/test_abstract_shell.cpp	2015-10-07 06:10:46 +0000
@@ -32,11 +32,13 @@
  #include "mir/test/doubles/mock_surface_coordinator.h"
  #include "mir/test/doubles/mock_session_listener.h"
  #include "mir/test/doubles/mock_surface.h"
++#include "mir/test/doubles/null_event_sink.h"
  #include "mir/test/doubles/null_snapshot_strategy.h"
  #include "mir/test/doubles/null_prompt_session_manager.h"
  #include "mir/test/doubles/stub_input_targeter.h"
  #include "mir/test/doubles/stub_buffer_stream_factory.h"
  #include "mir/test/doubles/null_application_not_responding_detector.h"
++#include "mir/test/doubles/stub_display.h"
  #include "mir/test/fake_shared.h"
@@ -48,6 +50,7 @@
  namespace ms = mir::scene;
  namespace msh = mir::shell;
  namespace geom = mir::geometry;
++namespace mg = mir::graphics;
  namespace mt = mir::test;
  namespace mtd = mir::test::doubles;
@@ -105,6 +108,7 @@
      NiceMock<MockSessionEventSink> session_event_sink;
      NiceMock<mtd::MockSessionListener> session_listener;
      NiceMock<MockSurfaceFactory> surface_factory;
++    mtd::StubDisplay display{3};
      NiceMock<MockSessionManager> session_manager{
          mt::fake_shared(surface_coordinator),
@@ -114,6 +118,7 @@
          std::make_shared<mtd::NullSnapshotStrategy>(),
          mt::fake_shared(session_event_sink),
          mt::fake_shared(session_listener),
++        mt::fake_shared(display),
          std::make_shared<mtd::NullANRDetector>()};
      mtd::StubInputTargeter input_targeter;
@@ -131,6 +136,8 @@
          ON_CALL(session_container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
          ON_CALL(session_manager, set_focus_to(_)).
              WillByDefault(Invoke(&session_manager, &MockSessionManager::unmocked_set_focus_to));
++        ON_CALL(mock_surface, size())
++            .WillByDefault(Return(geom::Size{}));
          ON_CALL(surface_factory, create_surface(_,_))
              .WillByDefault(Return(mt::fake_shared(mock_surface)));
+     }
@@ -390,7 +397,7 @@
      auto const session0 = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
      auto const session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
      NiceMock<mtd::MockSurface> dummy_surface;
--
++    ON_CALL(dummy_surface, size()).WillByDefault(Return(geom::Size{}));
      EXPECT_CALL(surface_factory, create_surface(_,_)).Times(AnyNumber())
          .WillOnce(Return(mt::fake_shared(dummy_surface)))
          .WillOnce(Return(mt::fake_shared(mock_surface)));
@@ -404,7 +411,7 @@
      auto const surface1 = session1->surface(surface1_id);
      msh::FocusController& focus_controller = shell;
--;
++
      focus_controller.set_focus_to(session0, surface0);
      EXPECT_THAT(focus_controller.focused_surface(), Eq(surface0));
      focus_controller.set_focus_to(session1, surface1);
 === modified file 'tests/unit-tests/scene/test_application_session.cpp'
 --- tests/unit-tests/scene/test_application_session.cpp	2015-09-24 00:35:49 +0000
 +++ tests/unit-tests/scene/test_application_session.cpp	2015-10-07 06:10:46 +0000
@@ -34,6 +34,7 @@
  #include "mir/test/doubles/null_event_sink.h"
  #include "mir/test/doubles/mock_event_sink.h"
  #include "mir/test/doubles/null_prompt_session.h"
++#include "mir/test/doubles/stub_display_configuration.h"
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
@@ -51,7 +52,10 @@
+ {
  static std::shared_ptr<mtd::MockSurface> make_mock_surface()
+ {
--    return std::make_shared<testing::NiceMock<mtd::MockSurface> >();
++    using namespace testing;
++    auto surface = std::make_shared<NiceMock<mtd::MockSurface>>();
++    ON_CALL(*surface, size()).WillByDefault(Return(geom::Size { 100, 100 }));
++    return surface;
+ }
  struct MockBufferStreamFactory : public ms::BufferStreamFactory
@@ -98,6 +102,11 @@
      return arg.parent.lock() == parent;
+ }
++MATCHER(IsSurfaceOutputEvent, "")
++{
++    return mir_event_get_type(&arg) == mir_event_type_surface_output;
++}
++
  struct StubSurfaceCoordinator : public ms::SurfaceCoordinator
+ {
      void raise(std::weak_ptr<ms::Surface> const&) override
@@ -138,6 +147,7 @@
             pid, name,
             null_snapshot_strategy,
             stub_session_listener,
++           mtd::StubDisplayConfig{},
             event_sink);
+     }
@@ -150,6 +160,7 @@
             pid, name,
             null_snapshot_strategy,
             stub_session_listener,
++           mtd::StubDisplayConfig{},
             event_sink);
+     }
@@ -162,6 +173,7 @@
             pid, name,
             null_snapshot_strategy,
             stub_session_listener,
++           mtd::StubDisplayConfig{},
             event_sink);
+     }
      std::shared_ptr<ms::ApplicationSession> make_application_session_with_coordinator(
@@ -172,6 +184,7 @@
             pid, name,
             null_snapshot_strategy,
             stub_session_listener,
++           mtd::StubDisplayConfig{},
             event_sink);
+     }
@@ -183,6 +196,7 @@
             pid, name,
             null_snapshot_strategy,
             session_listener,
++           mtd::StubDisplayConfig{},
             event_sink);
+     }
@@ -195,6 +209,7 @@
             pid, name,
             null_snapshot_strategy,
             stub_session_listener,
++           mtd::StubDisplayConfig{},
             event_sink);
+     }
@@ -232,7 +247,7 @@
          mt::fake_shared(surface_coordinator), mt::fake_shared(mock_surface_factory));
      ms::SurfaceCreationParameters params;
--    auto surf = session->create_surface(params, nullptr);
++    auto surf = session->create_surface(params, event_sink);
      session->destroy_surface(surf);
+ }
@@ -250,7 +265,7 @@
      auto session = make_application_session_with_listener(mt::fake_shared(listener));
      ms::SurfaceCreationParameters params;
--    auto surf = session->create_surface(params, nullptr);
++    auto surf = session->create_surface(params, event_sink);
      session->destroy_surface(surf);
+ }
@@ -269,7 +284,7 @@
          auto session = make_application_session_with_listener(mt::fake_shared(listener));
          ms::SurfaceCreationParameters params;
--        session->create_surface(params, nullptr);
++        session->create_surface(params, event_sink);
+     }
+ }
@@ -398,7 +413,7 @@
+     }
      ms::SurfaceCreationParameters params;
--    auto surf = app_session->create_surface(params, nullptr);
++    auto surf = app_session->create_surface(params, event_sink);
      app_session->hide();
      app_session->show();
@@ -429,9 +444,10 @@
          pid, name,
          snapshot_strategy,
          std::make_shared<ms::NullSessionListener>(),
++        mtd::StubDisplayConfig{},
          event_sink);
--    auto surface = app_session.create_surface(ms::SurfaceCreationParameters{}, nullptr);
++    auto surface = app_session.create_surface(ms::SurfaceCreationParameters{}, event_sink);
      app_session.take_snapshot(ms::SnapshotCallback());
      app_session.destroy_surface(surface);
+ }
@@ -449,6 +465,7 @@
          pid, name,
          snapshot_strategy,
          std::make_shared<ms::NullSessionListener>(),
++        mtd::StubDisplayConfig{},
          event_sink);
      EXPECT_CALL(*snapshot_strategy, take_snapshot_of(_,_)).Times(0);
@@ -469,6 +486,7 @@
          session_pid, name,
          null_snapshot_strategy,
          std::make_shared<ms::NullSessionListener>(),
++        mtd::StubDisplayConfig{},
          event_sink);
      EXPECT_THAT(app_session.process_id(), Eq(session_pid));
@@ -493,7 +511,7 @@
      ms::SurfaceCreationParameters params;
--    auto id1 = session->create_surface(params, nullptr);
++    auto id1 = session->create_surface(params, event_sink);
      EXPECT_THAT(session->get_buffer_stream(mf::BufferStreamId(id1.as_value())), Eq(stub_bstream));
      EXPECT_THAT(session->get_surface(id1), Eq(mock_surface));
@@ -508,7 +526,7 @@
+ {
      auto session = make_application_session_with_stubs();
      ms::SurfaceCreationParameters params;
--    auto id = session->create_surface(params, nullptr);
++    auto id = session->create_surface(params, event_sink);
      mf::BufferStreamId stream_id(id.as_value());
      session->destroy_buffer_stream(stream_id);
      EXPECT_THROW({
@@ -550,7 +568,7 @@
      auto stream_id0 = mf::BufferStreamId(
          session->create_surface(
              ms::a_surface().of_position({1,1}),
--            nullptr).as_value());
++            event_sink).as_value());
      auto stream_id1 = session->create_buffer_stream(stream_properties);
      auto stream_id2 = session->create_buffer_stream(stream_properties);
@@ -614,7 +632,7 @@
      EXPECT_CALL(mock_surface_factory, create_surface(Eq(session->get_buffer_stream(id)),_))
          .WillOnce(Invoke([&](auto bs, auto)
+     {
--        auto surface = std::make_shared<NiceMock<mtd::MockSurface>>();
++        auto surface = make_mock_surface();
          ON_CALL(*surface, primary_buffer_stream())
              .WillByDefault(Return(bs));
          return surface;
@@ -625,7 +643,7 @@
          .of_type(mir_surface_type_normal)
          .with_buffer_stream(id);
--    auto surface_id = session->create_surface(params, nullptr);
++    auto surface_id = session->create_surface(params, event_sink);
      auto surface = session->get_surface(surface_id);
      EXPECT_THAT(surface->primary_buffer_stream(), Eq(session->get_buffer_stream(id)));
@@ -637,12 +655,19 @@
+ {
      ApplicationSessionSender() :
          app_session(
--        stub_surface_coordinator, stub_surface_factory, stub_buffer_stream_factory,
--        pid, name,null_snapshot_strategy, stub_session_listener, mt::fake_shared(sender))
++            stub_surface_coordinator,
++            stub_surface_factory,
++            stub_buffer_stream_factory,
++            pid,
++            name,
++            null_snapshot_strategy,
++            stub_session_listener,
++            mtd::StubDisplayConfig{},
++            mt::fake_shared(sender))
+     {
+     }
--    mtd::MockEventSink sender;
++    testing::NiceMock<mtd::MockEventSink> sender;
      ms::ApplicationSession app_session;
  };
+ }
@@ -683,3 +708,430 @@
      EXPECT_CALL(sender, handle_event(EqPromptSessionEventState(mir_prompt_session_state_stopped))).Times(1);
      app_session.stop_prompt_session();
+ }
++
++namespace
++{
++class ObserverPreservingSurface : public mtd::MockSurface
++{
++public:
++    void add_observer(std::shared_ptr<mir::scene::SurfaceObserver> const &observer) override
++    {
++        return BasicSurface::add_observer(observer);
++    }
++
++    void remove_observer(std::weak_ptr<mir::scene::SurfaceObserver> const &observer) override
++    {
++        return BasicSurface::remove_observer(observer);
++    }
++};
++
++class ObserverPreservingSurfaceFactory : public ms::SurfaceFactory
++{
++public:
++    std::shared_ptr<ms::Surface> create_surface(
++        std::shared_ptr<mir::compositor::BufferStream> const&,
++        mir::scene::SurfaceCreationParameters const& params) override
++    {
++        using namespace testing;
++        auto mock = std::make_shared<NiceMock<ObserverPreservingSurface>>();
++        ON_CALL(*mock, size()).WillByDefault(Return(params.size));
++        return mock;
++    };
++};
++
++int calculate_dpi(geom::Size const& resolution, geom::Size const& size)
++{
++    float constexpr mm_per_inch = 25.4f;
++
++    auto diagonal_mm = sqrt(size.height.as_int()*size.height.as_int()
++                            + size.width.as_int()*size.width.as_int());
++    auto diagonal_px = sqrt(resolution.height.as_int() * resolution.height.as_int()
++                            + resolution.width.as_int() * resolution.width.as_int());
++
++    return diagonal_px / diagonal_mm * mm_per_inch;
++}
++
++struct ApplicationSessionSurfaceOutput : public ApplicationSession
++{
++    ApplicationSessionSurfaceOutput() :
++        high_dpi({3840, 2160}, {509, 286}, 2.5f, mir_form_factor_monitor),
++        projector({1280, 1024}, {800, 600}, 0.5f, mir_form_factor_projector),
++        stub_surface_factory{std::make_shared<ObserverPreservingSurfaceFactory>()},
++        sender{std::make_shared<testing::NiceMock<mtd::MockEventSink>>()},
++        app_session(
++            stub_surface_coordinator,
++            stub_surface_factory,
++            stub_buffer_stream_factory,
++            pid,
++            name,
++            null_snapshot_strategy,
++            stub_session_listener,
++            mtd::StubDisplayConfig{},
++            sender)
++    {
++    }
++
++    struct TestOutput
++    {
++        TestOutput(
++            geom::Size const& resolution,
++            geom::Size const& physical_size,
++            float scale,
++            MirFormFactor form_factor) :
++            output{resolution, physical_size, mir_pixel_format_argb_8888, 60.0, true},
++            form_factor{form_factor},
++            scale{scale},
++            dpi{calculate_dpi(resolution, physical_size)},
++            width{resolution.width.as_int()}
++        {
++            output.scale = scale;
++            output.form_factor = form_factor;
++        }
++
++        mtd::StubDisplayConfigurationOutput output;
++        MirFormFactor form_factor;
++        float scale;
++        int dpi;
++        int width;
++    };
++
++    TestOutput const high_dpi;
++    TestOutput const projector;
++    std::shared_ptr<ms::SurfaceFactory> const stub_surface_factory;
++    std::shared_ptr<testing::NiceMock<mtd::MockEventSink>> sender;
++    ms::ApplicationSession app_session;
++};
++}
++
++namespace
++{
++MATCHER_P(SurfaceOutputEventFor, output, "")
++{
++    using namespace testing;
++
++    if (mir_event_get_type(arg) != mir_event_type_surface_output)
++    {
++        *result_listener << "Event is not a MirSurfaceOutputEvent";
++        return 0;
++    }
++
++    auto const event = mir_event_get_surface_output_event(arg);
++    return
++        ExplainMatchResult(
++            Eq(output.dpi),
++            mir_surface_output_event_get_dpi(event),
++            result_listener) &&
++        ExplainMatchResult(
++            Eq(output.form_factor),
++            mir_surface_output_event_get_form_factor(event),
++            result_listener) &&
++        ExplainMatchResult(
++            Eq(output.scale),
++            mir_surface_output_event_get_scale(event),
++            result_listener);
++}
++}
++
++TEST_F(ApplicationSessionSurfaceOutput, sends_surface_output_events_to_surfaces)
++{
++    using namespace ::testing;
++
++    MirEvent event;
++    bool event_received{false};
++
++    EXPECT_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
++        .WillOnce(Invoke([&event, &event_received](auto ev)
++                         {
++                             event = ev;
++                             event_received = true;
++                         }));
++
++    std::vector<mg::DisplayConfigurationOutput> outputs =
++        {
++            high_dpi.output
++        };
++    mtd::StubDisplayConfig config(outputs);
++    app_session.send_display_config(config);
++
++    ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
++        .of_size({100, 100});
++    auto surf_id = app_session.create_surface(params, sender);
++    auto surface = app_session.surface(surf_id);
++
++    ASSERT_TRUE(event_received);
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
++}
++
++TEST_F(ApplicationSessionSurfaceOutput, sends_correct_surface_details_to_surface)
++{
++    using namespace ::testing;
++
++    std::array<TestOutput const*, 2> outputs{{ &high_dpi, &projector }};
++
++    std::array<MirEvent, 2> event;
++    int events_received{0};
++
++    ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
++        .WillByDefault(Invoke([&event, &events_received](auto ev)
++                         {
++                             event[events_received] = ev;
++                             ++events_received;
++                         }));
++
++    ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
++        .of_size({100, 100});
++
++    mf::SurfaceId ids[2];
++    std::shared_ptr<ms::Surface> surfaces[2];
++
++    ids[0] = app_session.create_surface(params, sender);
++    ids[1] = app_session.create_surface(params, sender);
++
++    surfaces[0] = app_session.surface(ids[0]);
++    surfaces[1] = app_session.surface(ids[1]);
++
++    surfaces[0]->move_to({0 + 100, 100});
++    surfaces[1]->move_to({outputs[0]->width + 100, 100});
++
++    // Reset events recieved; we may have received events from the move.
++    events_received = 0;
++
++    std::vector<mg::DisplayConfigurationOutput> configuration_outputs =
++        {
++            outputs[0]->output, outputs[1]->output
++        };
++    configuration_outputs[0].top_left = {0, 0};
++    configuration_outputs[1].top_left = {outputs[0]->width, 0};
++
++    mtd::StubDisplayConfig config(configuration_outputs);
++    app_session.send_display_config(config);
++
++    ASSERT_THAT(events_received, Eq(2));
++
++    for (int i = 0; i < 2 ; ++i)
++    {
++        EXPECT_THAT(event[i].surface_output.surface_id, Eq(ids[i].as_value()));
++        EXPECT_THAT(&event[i], SurfaceOutputEventFor(*outputs[i]));
++    }
++}
++
++TEST_F(ApplicationSessionSurfaceOutput, sends_details_of_the_hightest_scale_factor_display_on_overlap)
++{
++    using namespace ::testing;
++
++    std::array<TestOutput const*, 2> outputs{{ &projector, &high_dpi }};
++
++    MirEvent event;
++    bool event_received{false};
++
++    ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
++        .WillByDefault(Invoke([&event, &event_received](auto ev)
++                              {
++                                  event = ev;
++                                  event_received = true;
++                              }));
++
++    ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
++        .of_size({100, 100});
++
++    auto id = app_session.create_surface(params, sender);
++    auto surface = app_session.surface(id);
++
++    // This should overlap both outputs
++    surface->move_to({outputs[0]->width - 50, 100});
++
++    std::vector<mg::DisplayConfigurationOutput> configuration_outputs =
++        {
++            outputs[0]->output, outputs[1]->output
++        };
++
++    // Put the higher-scale output on the right, so a surface's top_left coordinate
++    // can be in the lower-scale output but overlap with the higher-scale output.
++    configuration_outputs[0].top_left = {0, 0};
++    configuration_outputs[1].top_left = {outputs[0]->width, 0};
++
++    mtd::StubDisplayConfig config(configuration_outputs);
++    app_session.send_display_config(config);
++
++    ASSERT_TRUE(event_received);
++
++    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
++}
++
++TEST_F(ApplicationSessionSurfaceOutput, surfaces_on_edges_get_correct_values)
++{
++    using namespace ::testing;
++
++    std::array<TestOutput const*, 2> outputs{{ &projector, &high_dpi }};
++
++    MirEvent event;
++    bool event_received{false};
++
++    ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
++        .WillByDefault(Invoke([&event, &event_received](auto ev)
++                              {
++                                  event = ev;
++                                  event_received = true;
++                              }));
++
++    std::vector<mg::DisplayConfigurationOutput> configuration_outputs =
++        {
++            outputs[0]->output, outputs[1]->output
++        };
++
++    // Put the higher-scale output on the right, so a surface's top_left coordinate
++    // can be in the lower-scale output but overlap with the higher-scale output.
++    configuration_outputs[0].top_left = {0, 0};
++    configuration_outputs[1].top_left = {outputs[0]->width, 0};
++
++    mtd::StubDisplayConfig config(configuration_outputs);
++    app_session.send_display_config(config);
++
++    ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
++        .of_size({640, 480});
++
++    auto id = app_session.create_surface(params, sender);
++    auto surface = app_session.surface(id);
++
++    // This should solidly overlap both outputs
++    surface->move_to({outputs[0]->width - ((surface->size().width.as_uint32_t()) / 2), 100});
++
++    ASSERT_TRUE(event_received);
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
++
++    event_received = false;
++    // This should be *just* entirely on the projector
++    surface->move_to({outputs[0]->width - surface->size().width.as_uint32_t(), 100});
++
++    ASSERT_TRUE(event_received);
++    EXPECT_THAT(&event, SurfaceOutputEventFor(projector));
++
++    event_received = false;
++    // This should have a single pixel overlap on the high_dpi
++    surface->move_to({outputs[0]->width - (surface->size().width.as_uint32_t() - 1), 100});
++
++    ASSERT_TRUE(event_received);
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
++}
++
++TEST_F(ApplicationSessionSurfaceOutput, sends_surface_output_event_on_move)
++{
++    using namespace ::testing;
++
++    std::array<TestOutput const*, 2> outputs {{ &projector, &high_dpi }};
++
++    MirEvent event;
++    int events_received{0};
++
++
++    ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
++        .WillByDefault(Invoke([&event, &events_received](auto ev)
++                              {
++                                  event = ev;
++                                  events_received++;
++                              }));
++
++    std::vector<mg::DisplayConfigurationOutput> configuration_outputs =
++        {
++            outputs[0]->output, outputs[1]->output
++        };
++
++    // Put the higher-scale output on the right, so a surface's top_left coordinate
++    // can be in the lower-scale output but overlap with the higher-scale output.
++    configuration_outputs[0].top_left = {0, 0};
++    configuration_outputs[1].top_left = {outputs[0]->width, 0};
++
++    mtd::StubDisplayConfig config(configuration_outputs);
++    app_session.send_display_config(config);
++
++    ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
++        .of_size({100, 100});
++
++    auto id = app_session.create_surface(params, sender);
++    auto surface = app_session.surface(id);
++
++    // This should overlap both outputs
++    surface->move_to({outputs[0]->width - 50, 100});
++
++
++    ASSERT_THAT(events_received, Ge(1));
++    auto events_expected = events_received + 1;
++
++    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
++
++    // Now solely on the left output
++    surface->move_to({0, 0});
++
++    ASSERT_THAT(events_received, Eq(events_expected));
++    events_expected++;
++
++    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(projector));
++
++    // Now solely on the right output
++    surface->move_to({outputs[0]->width + 100, 100});
++
++    ASSERT_THAT(events_received, Eq(events_expected));
++    events_expected++;
++
++    EXPECT_THAT(event.surface_output.surface_id, Eq(id.as_value()));
++    EXPECT_THAT(&event, SurfaceOutputEventFor(high_dpi));
++}
++
++TEST_F(ApplicationSessionSurfaceOutput, sends_surface_output_event_on_move_only_if_changed)
++{
++    using namespace ::testing;
++
++    std::array<TestOutput const*, 2> outputs {{ &projector, &high_dpi }};
++
++    MirEvent event;
++    int events_received{0};
++
++    ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
++        .WillByDefault(Invoke([&event, &events_received](auto ev)
++                              {
++                                  event = ev;
++                                  events_received++;
++                              }));
++
++    std::vector<mg::DisplayConfigurationOutput> configuration_outputs =
++        {
++            outputs[0]->output, outputs[1]->output
++        };
++
++    // Put the higher-scale output on the right, so a surface's top_left coordinate
++    // can be in the lower-scale output but overlap with the higher-scale output.
++    configuration_outputs[0].top_left = {0, 0};
++    configuration_outputs[1].top_left = {outputs[0]->width, 0};
++
++    mtd::StubDisplayConfig config(configuration_outputs);
++    app_session.send_display_config(config);
++
++    ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
++        .of_size({100, 100});
++
++    auto id = app_session.create_surface(params, sender);
++    auto surface = app_session.surface(id);
++
++    // We get an event on surface creation.
++    EXPECT_THAT(events_received, Eq(1));
++
++    // This should move within the same output, so not generate any events
++    surface->move_to({outputs[0]->width - (surface->size().width.as_int() + 1), 100});
++
++    EXPECT_THAT(events_received, Eq(1));
++
++    // This should move to *exactly* touching the edge of the output; still no events
++    surface->move_to({outputs[0]->width - surface->size().width.as_int(), 100});
++    EXPECT_THAT(events_received, Eq(1));
++
++    // This should move to just overlaping the second output; should generate an event
++    surface->move_to({outputs[0]->width - (surface->size().width.as_int() - 1), 100});
++    EXPECT_THAT(events_received, Eq(2));
++
++    // Back to exactly on the original display; another event.
++    surface->move_to({outputs[0]->width - surface->size().width.as_int(), 100});
++    EXPECT_THAT(events_received, Eq(3));
++}
 === modified file 'tests/unit-tests/scene/test_session_manager.cpp'
 --- tests/unit-tests/scene/test_session_manager.cpp	2015-09-24 00:35:49 +0000
 +++ tests/unit-tests/scene/test_session_manager.cpp	2015-10-07 06:10:46 +0000
@@ -33,8 +33,10 @@
  #include "mir/test/doubles/stub_buffer_stream_factory.h"
  #include "mir/test/doubles/null_snapshot_strategy.h"
  #include "mir/test/doubles/null_session_event_sink.h"
++#include "mir/test/doubles/null_event_sink.h"
  #include "mir/test/doubles/stub_surface_factory.h"
  #include "mir/test/doubles/null_application_not_responding_detector.h"
++#include "mir/test/doubles/stub_display.h"
  #include "mir/test/fake_shared.h"
@@ -91,6 +93,8 @@
      ms::NullSessionListener session_listener;
      mtd::StubBufferStreamFactory buffer_stream_factory;
      mtd::StubSurfaceFactory stub_surface_factory;
++    mtd::StubDisplay display{2};
++    mtd::NullEventSink event_sink;
      ms::SessionManager session_manager{mt::fake_shared(surface_coordinator),
          mt::fake_shared(stub_surface_factory),
@@ -99,6 +103,7 @@
          std::make_shared<mtd::NullSnapshotStrategy>(),
          std::make_shared<mtd::NullSessionEventSink>(),
          mt::fake_shared(session_listener),
++        mt::fake_shared(display),
          std::make_shared<mtd::NullANRDetector>()};
  };
@@ -111,7 +116,7 @@
      EXPECT_CALL(container, insert_session(_)).Times(1);
      EXPECT_CALL(container, remove_session(_)).Times(1);
--    auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
++    auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", mt::fake_shared(event_sink));
      session_manager.close_session(session);
+ }
@@ -124,10 +129,10 @@
      EXPECT_CALL(container, insert_session(_)).Times(1);
      EXPECT_CALL(container, remove_session(_)).Times(1);
--    auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
++    auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", mt::fake_shared(event_sink));
      session->create_surface(
          ms::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}),
--        nullptr);
++        mt::fake_shared(event_sink));
      session_manager.close_session(session);
+ }
@@ -146,6 +151,7 @@
      testing::NiceMock<MockSessionContainer> container;
      testing::NiceMock<mtd::MockSessionListener> session_listener;
      mtd::StubSurfaceFactory stub_surface_factory;
++    mtd::StubDisplay display{2};
      ms::SessionManager session_manager{
          mt::fake_shared(surface_coordinator),
@@ -155,6 +161,7 @@
          std::make_shared<mtd::NullSnapshotStrategy>(),
          std::make_shared<mtd::NullSessionEventSink>(),
          mt::fake_shared(session_listener),
++        mt::fake_shared(display),
          std::make_shared<mtd::NullANRDetector>()};
  };
+ }
@@ -185,6 +192,7 @@
      MockSessionEventSink session_event_sink;
      testing::NiceMock<mtd::MockSessionListener> session_listener;
      mtd::StubSurfaceFactory stub_surface_factory;
++    mtd::StubDisplay display{3};
      ms::SessionManager session_manager{
          mt::fake_shared(surface_coordinator),
@@ -194,6 +202,7 @@
          std::make_shared<mtd::NullSnapshotStrategy>(),
          mt::fake_shared(session_event_sink),
          mt::fake_shared(session_listener),
++        mt::fake_shared(display),
          std::make_shared<mtd::NullANRDetector>()};
  };
+ }
 === modified file 'tests/unit-tests/scene/test_surface.cpp'
 --- tests/unit-tests/scene/test_surface.cpp	2015-08-13 21:44:58 +0000
 +++ tests/unit-tests/scene/test_surface.cpp	2015-10-07 06:10:46 +0000
@@ -21,6 +21,7 @@
  #include "src/server/scene/basic_surface.h"
  #include "src/server/scene/legacy_surface_change_notification.h"
  #include "src/server/report/null_report_factory.h"
++#include "src/server/scene/output_properties_cache.h"
  #include "mir/frontend/event_sink.h"
  #include "mir/scene/surface_creation_parameters.h"
  #include "mir/scene/surface_event_source.h"
@@ -268,7 +269,8 @@
          .Times(1);
      auto const mock_event_sink = std::make_shared<MockEventSink>();
--    auto const observer = std::make_shared<ms::SurfaceEventSource>(mf::SurfaceId(), mock_event_sink);
++    ms::OutputPropertiesCache cache;
++    auto const observer = std::make_shared<ms::SurfaceEventSource>(mf::SurfaceId(), surface, cache, mock_event_sink);
      surface.add_observer(observer);
@@ -284,7 +286,8 @@
      using namespace testing;
      geom::Size const new_size{123, 456};
      auto const mock_event_sink = std::make_shared<MockEventSink>();
--    auto const observer = std::make_shared<ms::SurfaceEventSource>(mf::SurfaceId(), mock_event_sink);
++    ms::OutputPropertiesCache cache;
++    auto const observer = std::make_shared<ms::SurfaceEventSource>(mf::SurfaceId(), surface, cache, mock_event_sink);
      surface.add_observer(observer);
 === modified file 'tests/unit-tests/scene/test_surface_impl.cpp'
 --- tests/unit-tests/scene/test_surface_impl.cpp	2015-06-26 08:00:59 +0000
 +++ tests/unit-tests/scene/test_surface_impl.cpp	2015-10-07 06:10:46 +0000
@@ -24,6 +24,7 @@
  #include "src/server/report/null_report_factory.h"
  #include "mir/frontend/event_sink.h"
  #include "mir/graphics/display_configuration.h"
++#include "src/server/scene/output_properties_cache.h"
  #include "mir/test/doubles/stub_buffer_stream.h"
  #include "mir/test/doubles/mock_buffer_stream.h"
@@ -173,7 +174,8 @@
      geom::Size const new_size{123, 456};
      auto sink = std::make_shared<mtd::MockEventSink>();
--    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, sink);
++    ms::OutputPropertiesCache cache;
++    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, *surface, cache, sink);
      surface->add_observer(observer);
@@ -192,7 +194,8 @@
      geom::Size const new_size{123, 456};
      geom::Size const new_size2{789, 1011};
      auto sink = std::make_shared<mtd::MockEventSink>();
--    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, sink);
++    ms::OutputPropertiesCache cache;
++    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, *surface, cache, sink);
      surface->add_observer(observer);
@@ -229,7 +232,8 @@
              .Times(1);
+     }
--    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, mt::fake_shared(sink));
++    ms::OutputPropertiesCache cache;
++    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, *surface, cache, mt::fake_shared(sink));
      surface->add_observer(observer);
@@ -242,7 +246,8 @@
      using namespace testing;
      auto sink = std::make_shared<mtd::MockEventSink>();
--    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, sink);
++    ms::OutputPropertiesCache cache;
++    auto const observer = std::make_shared<ms::SurfaceEventSource>(stub_id, *surface, cache, sink);
      surface->add_observer(observer);