Merge lp:~mir-team/mir/vsync-timings-from-server into lp:mir

[Robert Carr]

Send vsync times from server and use in input resampling

Implement vsync timed input resampling as discussed in DC. Lots of noise in the test framework generated by the discovery that UsingStubClientAPI was not working (discovered by the vsync->input thread integration test).

Please test on device and tell me what you think.

[lp:~mir-team/mir/vsync-timings-from-server]

2024. By Robert Carr on 2014-11-05

Cleanup

[Robert Carr (robertcarr)]

The score is consistently better on the frame uniformity test but still not as good as you would want...if you look at distance per sample you see it go down to near zero pixels, but then slowly creep back up 1 pixel at a time. Still its both more responsive and uniform than the existing code or the code before the "synthetic vsync interval" sort of approach.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2023
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~mir-team/mir/vsync-timings-from-server/+merge/240789/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mir-ci/2012/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1/console

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

review: Needs Fixing (continuous-integration)

[Robert Carr (robertcarr)]

When testing you may notice that shell elements, i.e. indicator bar seem more responsive than client elements...ultimately I think this is due to nesting.

I believe

https://code.launchpad.net/~mir-team/qtubuntu/dont-use-raw-pc/+merge/240796

presents some improvement though

[lp:~mir-team/mir/vsync-timings-from-server]

2025. By Robert Carr on 2014-11-05

Update ABI sha1sums

2026. By Robert Carr on 2014-11-05

Fix lgpl license on vsync provideR

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2024
http://jenkins.qa.ubuntu.com/job/mir-ci/2014/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/3/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2026
http://jenkins.qa.ubuntu.com/job/mir-ci/2015/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/5
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/4/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Slightly scary diff size right now, but could prove worthwhile. Initial thoughts:

(1) Avoid naming anything "*Provider". If a more concrete noun can't be found for such classes then that's an indication the design needs improving.

[Daniel van Vugt (vanvugt)]

Perhaps just a rename "VsyncSource". *shrug*

[lp:~mir-team/mir/vsync-timings-from-server]

2027. By Robert Carr on 2014-11-06

Merge lp:mir

[Daniel van Vugt (vanvugt)]

(2) Some very important regression tests have been deleted. I suspect it's possible to retain (convert?) them, so we should:
tests/unit-tests/client/input/test_android_input_receiver.cpp:
2488 -TEST_F(AndroidInputReceiverSetup, slow_raw_input_doesnt_cause_frameskipping)
2536 -TEST_F(AndroidInputReceiverSetup, rendering_does_not_lag_behind_input)

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

(3) Spurious line appears in a few files:
+e1be9faee8b844ca2ce617f8fd82c9ee08d56bed include/common/mir/graphics/#native_buffer.h#

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2027
http://jenkins.qa.ubuntu.com/job/mir-ci/2017/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/8
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/6/console

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

review: Needs Fixing (continuous-integration)

[lp:~mir-team/mir/vsync-timings-from-server]

2028. By Robert Carr on 2014-11-06

Fix swap files in sha1sums

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2028
http://jenkins.qa.ubuntu.com/job/mir-ci/2027/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/22
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/16/console

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

review: Needs Fixing (continuous-integration)

[lp:~mir-team/mir/vsync-timings-from-server]

2029. By Robert Carr on 2014-11-06

Remove backup file from sha1sums

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2029
http://jenkins.qa.ubuntu.com/job/mir-ci/2029/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/24
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/24
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/18
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/18/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3299/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/15531

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Now tested manually (Nexus4 nested and non-nested), but needs work...

(1) VsyncProvider: name could be better. VsyncSource? But see also (4)

(2) Some very important regression tests have been deleted. I suspect it's possible to retain (convert?) them, so we should:
tests/unit-tests/client/input/test_android_input_receiver.cpp:
2488 -TEST_F(AndroidInputReceiverSetup, slow_raw_input_doesnt_cause_frameskipping)
2536 -TEST_F(AndroidInputReceiverSetup, rendering_does_not_lag_behind_input)

(3) Nested input (fingerpaint -w) is visibly more laggy with this branch. That probably would have been shown by the test cases (2) had they not been deleted.

(4) Input event spacing is significantly less smooth and irregular (both nested and non-nested) with this branch. Same kind of irregularity pictured in bug 1373692. Also the same kind of irregularity I encountered when I experimented with a virtual vsync timer (when the client receives the buffer). So there's presently no visible advantage to getting timings from the server over what you can calculate within the client.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

(5) This looks like a bug and will cause resampling/prediction to be disabled:
480 + has_new_frame_time = false;

[Daniel van Vugt (vanvugt)]

Actually (4) could easily be explained by (5) :) There always is a last frame time; it should be perfectly regular and always known (be it real or artificial). And fixing (5) might fix the lag too (3).

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2029
http://jenkins.qa.ubuntu.com/job/mir-ci/2045/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/42/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/42/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/34/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/22/console

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

review: Needs Fixing (continuous-integration)

[lp:~mir-team/mir/vsync-timings-from-server]

2030. By Robert Carr on 2014-11-10

Merge lp:mir

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2030
http://jenkins.qa.ubuntu.com/job/mir-ci/2057/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/57
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/57
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/37/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/46
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/46/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/37/console

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

review: Needs Fixing (continuous-integration)

[lp:~mir-team/mir/vsync-timings-from-server]

2031. By Robert Carr on 2014-11-10

Forjenkins

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2031
http://jenkins.qa.ubuntu.com/job/mir-ci/2058/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/59
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/59
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/39/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/47
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/47/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/39
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/39/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3331/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/15650

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

review: Needs Fixing (continuous-integration)

[lp:~mir-team/mir/vsync-timings-from-server]

2032. By Robert Carr on 2014-11-10

Jenkins

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2032
http://jenkins.qa.ubuntu.com/job/mir-ci/2060/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/63
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/63
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/43
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/49
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/49/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/43
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/43/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3335
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/15658

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

CI failures logged as lp:1391488 (new) and lp:1391261 (confirmed)

[Alan Griffiths (alan-griffiths)]

71 + last_sync = std::chrono::high_resolution_clock::now();
72 + vsync_provider.notify_of_vsync(last_sync.time_since_epoch());

I note the use of real time within the tests - which is always a recipe for intermittent failures. I'd prefer to see a stubbed time source.

review: Abstain

[Kevin DuBois (kdub)]

First pass:

Could VsyncProvider be in mir::graphics instead of mir::frontend?

new whitespace
324 +

int64_t mir_surface_get_last_display_time(MirSurface *surface)
The naming has some interesting implications... like could the client api user rely on this to roughly see how long the screen has been off? Also, I'd think that the vsync stuff would be in mir_connection with the rest of the display stuff.

599 + virtual std::chrono::nanoseconds last_vsync_for(graphics::DisplayConfigurationOutputId output) = 0;
and
204 + virtual std::shared_ptr<frontend::VsyncProvider> the_vsync_provider();
and
184 + virtual std::shared_ptr<frontend::VsyncProvider> vsync_provider() = 0;

Seems like a lot of rigging where we could just have
mg::Display::last_vsync_for(graphics::DisplayConfigurationOutputId output) = 0;
and the server code could just use the existing the_display() function.

review: Needs Fixing

[Kevin DuBois (kdub)]

int64_t mir_surface_get_last_display_time(MirSurface *surface)
Somewhat related to my previous comment on this function, but is this exposing too much to the user? Is there some client-side processing that could be done in libmirclient without exposing the timing details?

The driving test looks like:
 2184 +TEST_F(VsyncProviderTest, last_display_time)
but could the test make use of mir client internals to check the vsync timing? (or, an uglier compromise could be for this to be in the debug library)

[Kevin DuBois (kdub)]

1098 + optional int64 vsync_time = 9;

Related to my comment about whether vsync info lives in the mir_surface_ vs mir_connection_ functions, it also seems to me that vsync is an event that can we can asynchronously notify clients of, as opposed to having this be synchronous with the exchange_buffer rpc call. This would also let us untie the buffer swapping from the vsync notification. (in case input processing is needed without the client wanting to swap a buffer)

[Daniel van Vugt (vanvugt)]

Vsync is more system-wide, certainly not per-connection. On the other hand you do need to avoid waking up all clients 60 times per second so querying per surface is a good compromise.

An even better solution is not having to get info from the server at all. So far there's no visible benefit in doing so, but if this branch gets fixed up and starts performing as well as trunk (or better!) then it could be justified.

[Kevin DuBois (kdub)]

> Vsync is more system-wide, certainly not per-connection. On the other hand you
> do need to avoid waking up all clients 60 times per second so querying per
> surface is a good compromise.

Sure, from a clients perspective though, the connection is the system wide graphics configuration. Its a good point that this would wake up the clients every time, perhaps that could be mitigated by the clients registering and deregistering a callback if they are interested.

If we tie the vsync to the buffers, we tie input processing tightly to the clients decision to submit new frames. (and the clients might submit dummy buffers they don't care about, just to get the vsync info)

> An even better solution is not having to get info from the server at all. So
> far there's no visible benefit in doing so, but if this branch gets fixed up
> and starts performing as well as trunk (or better!) then it could be
> justified.

Yes, this could be appropriate, but its tricky from the android platform at least (which only provides the vsync information from the hwc interface). Perhaps batching input at the same rate as one of the displays could be a way around.

[Alberto Aguirre (albaguirre)]

Text conflict in src/client/mir_surface_api.cpp

[Daniel van Vugt (vanvugt)]

Remember "batching" happens on the client side, which is surprising at first but actually very desirable. It means we have the option in future of letting clients turn off resampling if they're competent to deal with the raw events.

[Alberto Aguirre (albaguirre)]

These are some videos I took.

I don't notice any significant difference

Vivid #19 in mako:
https://drive.google.com/file/d/0B0EbX_l-W2rBOTZMSS0xamhWNXM/view?usp=sharing

Vivid #19 in mako + this branch:
https://drive.google.com/file/d/0B0EbX_l-W2rBMHhnajVqX3FJT0E/view?usp=sharing

[Daniel van Vugt (vanvugt)]

Alberto:
As racarr pointed out, native shell shell elements do perform OK still. However nested elements suffer significantly from this branch. To test nested elements you'll need to video something like a client (Ebay?), and not the shell itself.

[Daniel van Vugt (vanvugt)]

Oh I can see the terminology I used is misleading and confusing.

What we're actually talking about is _clients_ of nested servers having lag problems. And on the phone, that's most of what people are touching.

[Alberto Aguirre (albaguirre)]

@Daniel,

I used that more as an illustration that I don't see any visual benefits from this branch so far.

review: Abstain

[Chris Halse Rogers (raof)]

Doesn't seem unreasonable. I'm with Kevin though - is there a particular reason why get_last_vsync_for isn't a part of the Display interface?

It's a bit annoying that it needs to be exposed through the client API though. There are lots and lots of different interesting time values (see, for example, https://www.opengl.org/registry/specs/OML/glx_sync_control.txt) that we'll probably want to expose at some point - EGL/GL Next look like they'll want access to those things in the nearish future. I guess we can expose them (and possibly deprecate this API) when we come to that.

[Robert Carr (robertcarr)]

Sad that no one else experiences the performance the way I do. I experience it basically the same except during fast scrolls where I believe it is significantly more accurate in finger tracking. This is agreed with by frame uniformity test results.

Still I will continue working to produce a more convincing metric.

It is frustrating that mir_surface_get_last_display_time has to be exposed for nested. I agree it has some weird semantics if you think of it as vsync time, hence why I chose this name.

As chris references some clients are interested in this, Chromium uses VSync times + prediction to do...something! not sure beyond that.

>> sn't seem unreasonable. I'm with Kevin though - is there a particular reason why
>> get_last_vsync_for isn't a part of the Display interface?

I think putting it on the "Display" interface just further confuses the "Display"/"Output" terminology further...if Display why not DisplayBuffer?

[Robert Carr (robertcarr)]

Will switch to work in progress in a day or two if I dont make any progress.

Has anyone besides alberto and daniel tested?

Daniel: I wonder if in testing the nested clients you used the recommended qtubuntu branch? https://code.launchpad.net/~mir-team/qtubuntu/dont-use-raw-pc

Alberto: Maybe you could try some videos with some fast scrolls if its not too hard to setup?

[lp:~mir-team/mir/vsync-timings-from-server]

2033. By Robert Carr on 2014-11-17

Merge lp:mir

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2033
http://jenkins.qa.ubuntu.com/job/mir-ci/2135/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/162
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/162/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/142/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/124/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/142/console

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

review: Needs Fixing (continuous-integration)

[lp:~mir-team/mir/vsync-timings-from-server]

2034. By Robert Carr on 2014-11-18

Update sha1sums

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2034
http://jenkins.qa.ubuntu.com/job/mir-ci/2141/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/170
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/170
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/150/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/130
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/130/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/150
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/150/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3423/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/15931

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Also note -- if QtMir switches to using the newish Qt code (if not already?) which apparently does input resampling then we could theoretically just throw away all the resampling logic in Mir itself for now :)

I could be persuaded that fingerpaint being very laggy is a non-issue, but only if it's proven that QtMir is now using the in-toolkit input resampling feature. But if that's true then we're better off just deleting the resampling logic from Mir instead of growing it here.

[Robert Carr (robertcarr)]

I believe Qt is just doing a subset that we would call event compression. Will confirm.

[lp:~mir-team/mir/vsync-timings-from-server]

2035. By Robert Carr on 2014-11-18

Merge lp:mir

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2035
http://jenkins.qa.ubuntu.com/job/mir-ci/2156/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/191
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/191
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/171
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/145/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/171
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/171/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3441
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/15970

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

2035. By Robert Carr on 2014-11-18

Merge lp:mir

2034. By Robert Carr on 2014-11-18

Update sha1sums

2033. By Robert Carr on 2014-11-17

Merge lp:mir

2032. By Robert Carr on 2014-11-10

Jenkins

2031. By Robert Carr on 2014-11-10

Forjenkins

2030. By Robert Carr on 2014-11-10

Merge lp:mir

2029. By Robert Carr on 2014-11-06

Remove backup file from sha1sums

2028. By Robert Carr on 2014-11-06

Fix swap files in sha1sums

2027. By Robert Carr on 2014-11-06

Merge lp:mir

2026. By Robert Carr on 2014-11-05

Fix lgpl license on vsync provideR

=== modified file 'benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp'
--- benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2014-11-13 16:41:26 +0000
+++ benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2014-11-18 19:29:59 +0000
@@ -21,17 +21,23 @@
 #include "mir/graphics/buffer_writer.h"
 #include "mir/graphics/platform_ipc_operations.h"
 #include "mir/graphics/platform_ipc_package.h"
+#include "mir/frontend/vsync_provider.h"
+
+#include "mir_test/fake_shared.h"
 
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/stub_display.h"
 
 #include <chrono>
 #include <functional>
+#include <mutex>
 
+namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 
-namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 
 namespace
 {
@@ -43,7 +49,7 @@
     }
 };
 
-class StubIpcOps : public mg::PlatformIpcOperations
+struct StubIpcOps : public mg::PlatformIpcOperations
 {
     void pack_buffer(
         mg::BufferIpcMessage&,
@@ -68,6 +74,25 @@
     }
 };
 
+struct StubVsyncProvider : public mf::VsyncProvider
+{
+    std::chrono::nanoseconds last_vsync_for(mg::DisplayConfigurationOutputId /* output */)
+    {
+        std::unique_lock<std::mutex> lg(last_vsync_guard);
+
+        return last_vsync;
+    }
+
+    void notify_of_vsync(std::chrono::nanoseconds vsync)
+    {
+        std::unique_lock<std::mutex> lg(last_vsync_guard);
+
+        last_vsync = vsync;
+    }
+    std::mutex last_vsync_guard;
+    std::chrono::nanoseconds last_vsync;
+};
+
 struct StubDisplayBuffer : mtd::StubDisplayBuffer
 {
     StubDisplayBuffer(geom::Size output_size, int vsync_rate_in_hz)
@@ -84,13 +109,15 @@
         
         if (now < next_sync)
             std::this_thread::sleep_for(next_sync - now);
-        
-        last_sync = now;
+
+        last_sync = std::chrono::high_resolution_clock::now();
+        vsync_provider.notify_of_vsync(last_sync.time_since_epoch());
     }
     
     double const vsync_rate_in_hz;
 
     std::chrono::high_resolution_clock::time_point last_sync;
+    StubVsyncProvider vsync_provider;
 };
 
 struct StubDisplay : public mtd::StubDisplay
@@ -105,6 +132,11 @@
     {
         exec(buffer);
     }
+    
+    std::shared_ptr<mf::VsyncProvider> vsync_provider() override
+    {
+        return mt::fake_shared(buffer.vsync_provider);
+    }
 
     StubDisplayBuffer buffer;
 };
 
=== modified file 'client-ABI-sha1sums'
--- client-ABI-sha1sums	2014-11-12 05:01:53 +0000
+++ client-ABI-sha1sums	2014-11-18 19:29:59 +0000
@@ -5,7 +5,7 @@
 1ef8f51a3e3f8d1559266c5af58fbfde7cfabf0a  include/client/mir_toolkit/mir_cursor_configuration.h
 9d50df5a141ca03ee8a79f7e844ed4b8b3b7d5d3  include/client/mir_toolkit/mir_prompt_session.h
 21d07e655e85eeec8a3523e1c6f9c2252176ec01  include/client/mir_toolkit/mir_screencast.h
-4f85e3d00314a7df869e56c3701a45310909fae2  include/client/mir_toolkit/mir_surface.h
+1bacb90ea11be9c8fec6113a68391027ce518707  include/client/mir_toolkit/mir_surface.h
 b141c4d79802ad626d969249c0004744e5c2a525  include/client/mir_toolkit/mir_wait.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
 2100c0674d9d882c1845550847357f6a5de5af66  include/common/mir_toolkit/common.h
 
=== modified file 'common-ABI-sha1sums'
--- common-ABI-sha1sums	2014-11-11 07:34:31 +0000
+++ common-ABI-sha1sums	2014-11-18 19:29:59 +0000
@@ -7,7 +7,7 @@
 42646c2367b9821e3aa71feff6e31cf50526acaa  include/common/mir/geometry/size.h
 e1be9faee8b844ca2ce617f8fd82c9ee08d56bed  include/common/mir/graphics/native_buffer.h
 dcf8b8982f138bdde39a241825c610e955cd5e33  include/common/mir/input/input_platform.h
-208cd6aed5ef5f8f39b3eb86604e4133cb840485  include/common/mir/input/input_receiver_thread.h
+fc96edf0f28451af2009aff58b9da8c0d462a604  include/common/mir/input/input_receiver_thread.h
 be7d58c9fde2ce91cc66dd6144b76e08b536266b  include/common/mir/int_wrapper.h
 9ae8473df05dd9e048a73797f01a2f34f7447554  include/common/mir/time/types.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
 
=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2014-11-12 05:01:53 +0000
+++ include/client/mir_toolkit/mir_surface.h	2014-11-18 19:29:59 +0000
@@ -289,6 +289,13 @@
  */
 MirOrientation mir_surface_get_orientation(MirSurface *surface);
 
+/**
+ * Returns the last time a buffer from the surface was displayed on screen.
+ * If possible this time will be sampled on the server side from hardware
+ * vsync timings.
+ */
+int64_t mir_surface_get_last_display_time(MirSurface *surface);
+
 #ifdef __cplusplus
 }
 /**@}*/
 
=== modified file 'include/common/mir/input/input_receiver_thread.h'
--- include/common/mir/input/input_receiver_thread.h	2014-10-01 06:25:56 +0000
+++ include/common/mir/input/input_receiver_thread.h	2014-11-18 19:29:59 +0000
@@ -19,6 +19,8 @@
 #ifndef MIR_INPUT_RECEIVER_RECEIVER_THREAD_H_
 #define MIR_INPUT_RECEIVER_RECEIVER_THREAD_H_
 
+#include <chrono>
+
 namespace mir
 {
 namespace input
@@ -34,6 +36,8 @@
     virtual void start() = 0;
     virtual void stop() = 0;
     virtual void join() = 0;
+    
+    virtual void notify_of_frame_time(std::chrono::nanoseconds frame_time) = 0;
 
 protected:
     InputReceiverThread() = default;
 
=== modified file 'include/platform/mir/graphics/display.h'
--- include/platform/mir/graphics/display.h	2014-10-01 06:25:56 +0000
+++ include/platform/mir/graphics/display.h	2014-11-18 19:29:59 +0000
@@ -24,6 +24,10 @@
 
 namespace mir
 {
+namespace frontend
+{
+class VsyncProvider;
+}
 
 namespace graphics
 {
@@ -101,6 +105,12 @@
      * Create a hardware cursor object.
      */
     virtual std::shared_ptr<Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) = 0;
+    
+    /**
+     * Returns a vsync provider for the display which can provide per-output 
+     * information about vsync timings.
+     */
+    virtual std::shared_ptr<frontend::VsyncProvider> vsync_provider() = 0;
 
     /**
      * Creates a GLContext object that shares resources with the Display's GL context.
 
=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-11-18 17:26:29 +0000
+++ include/server/mir/default_server_configuration.h	2014-11-18 19:29:59 +0000
@@ -66,6 +66,7 @@
 class EventSink;
 class DisplayChanger;
 class Screencast;
+class VsyncProvider;
 }
 
 namespace shell
@@ -234,6 +235,7 @@
     virtual std::shared_ptr<frontend::EventSink>              the_global_event_sink();
     virtual std::shared_ptr<frontend::DisplayChanger>         the_frontend_display_changer();
     virtual std::shared_ptr<frontend::Screencast>             the_screencast();
+    virtual std::shared_ptr<frontend::VsyncProvider>          the_vsync_provider();
     /** @name frontend configuration - internal dependencies
      * internal dependencies of frontend
      *  @{ */
@@ -393,6 +395,7 @@
     CachedPtr<frontend::ConnectionCreator> connection_creator;
     CachedPtr<frontend::ConnectionCreator> prompt_connection_creator;
     CachedPtr<frontend::Screencast> screencast;
+    CachedPtr<frontend::VsyncProvider> vsync_provider;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
     CachedPtr<compositor::FrameDroppingPolicyFactory> frame_dropping_policy_factory;
 
=== modified file 'platform-ABI-sha1sums'
--- platform-ABI-sha1sums	2014-11-18 03:21:20 +0000
+++ platform-ABI-sha1sums	2014-11-18 19:29:59 +0000
@@ -7,7 +7,7 @@
 42646c2367b9821e3aa71feff6e31cf50526acaa  include/common/mir/geometry/size.h
 e1be9faee8b844ca2ce617f8fd82c9ee08d56bed  include/common/mir/graphics/native_buffer.h
 dcf8b8982f138bdde39a241825c610e955cd5e33  include/common/mir/input/input_platform.h
-208cd6aed5ef5f8f39b3eb86604e4133cb840485  include/common/mir/input/input_receiver_thread.h
+fc96edf0f28451af2009aff58b9da8c0d462a604  include/common/mir/input/input_receiver_thread.h
 be7d58c9fde2ce91cc66dd6144b76e08b536266b  include/common/mir/int_wrapper.h
 9ae8473df05dd9e048a73797f01a2f34f7447554  include/common/mir/time/types.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
@@ -28,7 +28,7 @@
 986f5d0d8ea2c6a42cc320f468e682f81fec46ae  include/platform/mir/graphics/display_buffer.h
 f53a0020b8f1bd4a941a201eb26271cffee0a7dd  include/platform/mir/graphics/display_configuration.h
 6fe08da318c920b0d20ea8b8f560f5ac7ed389fe  include/platform/mir/graphics/display_configuration_policy.h
-41ea906d208b761e3d5d5056095de9de2d4ffa17  include/platform/mir/graphics/display.h
+0eb20a383320790016fa22ae969e80fdecd20b8f  include/platform/mir/graphics/display.h
 815405c5aee8000bc18c1c9480bac620a451b416  include/platform/mir/graphics/event_handler_register.h
 5dc095474ef3e294c0aa4008e9ed997bdb21d34c  include/platform/mir/graphics/gl_config.h
 d0442a5d5d88a4be6e3e1f99e433c1c43a86bfce  include/platform/mir/graphics/gl_context.h
 
=== modified file 'server-ABI-sha1sums'
--- server-ABI-sha1sums	2014-11-18 17:26:29 +0000
+++ server-ABI-sha1sums	2014-11-18 19:29:59 +0000
@@ -7,7 +7,7 @@
 42646c2367b9821e3aa71feff6e31cf50526acaa  include/common/mir/geometry/size.h
 e1be9faee8b844ca2ce617f8fd82c9ee08d56bed  include/common/mir/graphics/native_buffer.h
 dcf8b8982f138bdde39a241825c610e955cd5e33  include/common/mir/input/input_platform.h
-208cd6aed5ef5f8f39b3eb86604e4133cb840485  include/common/mir/input/input_receiver_thread.h
+fc96edf0f28451af2009aff58b9da8c0d462a604  include/common/mir/input/input_receiver_thread.h
 be7d58c9fde2ce91cc66dd6144b76e08b536266b  include/common/mir/int_wrapper.h
 9ae8473df05dd9e048a73797f01a2f34f7447554  include/common/mir/time/types.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
@@ -28,7 +28,7 @@
 986f5d0d8ea2c6a42cc320f468e682f81fec46ae  include/platform/mir/graphics/display_buffer.h
 f53a0020b8f1bd4a941a201eb26271cffee0a7dd  include/platform/mir/graphics/display_configuration.h
 6fe08da318c920b0d20ea8b8f560f5ac7ed389fe  include/platform/mir/graphics/display_configuration_policy.h
-41ea906d208b761e3d5d5056095de9de2d4ffa17  include/platform/mir/graphics/display.h
+0eb20a383320790016fa22ae969e80fdecd20b8f  include/platform/mir/graphics/display.h
 815405c5aee8000bc18c1c9480bac620a451b416  include/platform/mir/graphics/event_handler_register.h
 5dc095474ef3e294c0aa4008e9ed997bdb21d34c  include/platform/mir/graphics/gl_config.h
 d0442a5d5d88a4be6e3e1f99e433c1c43a86bfce  include/platform/mir/graphics/gl_context.h
@@ -50,7 +50,7 @@
 d49eae4f986645b32e29ce2c1f99f524703ba3c0  include/server/mir/compositor/display_buffer_compositor.h
 878ab5c4007d16dac213a3eb0105421d8ffad206  include/server/mir/compositor/scene_element.h
 4fcf34e424128b87ddc76733594e32e09ebbd486  include/server/mir/compositor/scene.h
-bd13887133bab2dfaab764077983311485b233d0  include/server/mir/default_server_configuration.h
+67b99ce7b4571bc6141e7a1d6a0ea3e7de93a01b  include/server/mir/default_server_configuration.h
 af1ff0714be973ac76d56006a2e5991f68cd1dec  include/server/mir/display_server.h
 a35c5495d8fd28fc0e375b17495fc5caab51b329  include/server/mir/emergency_cleanup.h
 938de641cb0e01e1098b007b39b151a7dfe4adc1  include/server/mir/frontend/display_changer.h
 
=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2014-11-11 15:50:11 +0000
+++ src/client/mir_surface.cpp	2014-11-18 19:29:59 +0000
@@ -87,7 +87,8 @@
       debug{debug},
       connection(allocating_connection),
       buffer_depository(std::make_shared<mcl::ClientBufferDepository>(factory, mir::frontend::client_buffer_cache_size)),
-      input_platform(input_platform)
+      input_platform(input_platform),
+      last_display_time(std::chrono::nanoseconds::zero())
 {
     const char* report_target = getenv("MIR_CLIENT_PERF_REPORT");
     if (report_target && !strcmp(report_target, "log"))
@@ -248,6 +249,15 @@
         surface.set_height(buffer.height());
     }
 
+    if (buffer.has_vsync_time())
+    {
+        last_display_time = std::chrono::nanoseconds(buffer.vsync_time());
+        if (input_thread)
+        {
+            input_thread->notify_of_frame_time(last_display_time);
+        }
+    }
+
     auto surface_size = geom::Size{surface.width(), surface.height()};
     auto surface_pf = convert_ipc_pf_to_geometry(surface.pixel_format());
 
@@ -593,3 +603,10 @@
 
     return orientation;
 }
+
+std::chrono::nanoseconds MirSurface::get_last_display_time() const
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+
+    return last_display_time;
+}
 
=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2014-11-11 15:50:11 +0000
+++ src/client/mir_surface.h	2014-11-18 19:29:59 +0000
@@ -114,10 +114,12 @@
     void set_event_handler(MirEventDelegate const* delegate);
     void handle_event(MirEvent const& e);
 
+    std::chrono::nanoseconds get_last_display_time() const;
+
     /* mir::client::ClientSurface */
     void request_and_wait_for_next_buffer();
     void request_and_wait_for_configure(MirSurfaceAttrib a, int value);
-
+    
     static bool is_valid(MirSurface* query);
 private:
     mutable std::mutex mutex; // Protects all members of *this
@@ -147,6 +149,8 @@
     std::shared_ptr<mir::client::MemoryRegion> secured_region;
     std::shared_ptr<mir::client::ClientBufferDepository> buffer_depository;
     std::shared_ptr<mir::input::receiver::InputPlatform> const input_platform;
+    
+    std::chrono::nanoseconds last_display_time;
 
     std::shared_ptr<EGLNativeWindowType> accelerated_window;
 
 
=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2014-11-12 05:01:53 +0000
+++ src/client/mir_surface_api.cpp	2014-11-18 19:29:59 +0000
@@ -332,3 +332,8 @@
 
     return result;
 }
+
+int64_t mir_surface_get_last_display_time(MirSurface *surface)
+{
+    return surface->get_last_display_time().count();
+}
 
=== modified file 'src/common/input/android/android_input_receiver.cpp'
--- src/common/input/android/android_input_receiver.cpp	2014-10-21 16:21:14 +0000
+++ src/common/input/android/android_input_receiver.cpp	2014-11-18 19:29:59 +0000
@@ -39,7 +39,9 @@
     looper(new droidinput::Looper(true)),
     fd_added(false),
     xkb_mapper(std::make_shared<mircv::XKBMapper>()),
-    android_clock(clock)
+    android_clock(clock),
+    has_new_frame_time(false),
+    frame_time(-1)
 {
 }
 
@@ -52,7 +54,9 @@
     looper(new droidinput::Looper(true)),
     fd_added(false),
     xkb_mapper(std::make_shared<mircv::XKBMapper>()),
-    android_clock(clock)
+    android_clock(clock),
+    has_new_frame_time(false),
+    frame_time(-1)
 {
 }
 
@@ -85,49 +89,27 @@
     droidinput::InputEvent *android_event;
     uint32_t event_sequence_id;
 
-    /*
-     * Enable "Project Butter" input resampling in InputConsumer::consume():
-     *   consumeBatches = true, so as to ensure the "cooked" event rate that
-     *      clients experience is at least the minimum of event_rate_hz
-     *      and the raw device event rate.
-     *   frame_time = A regular interval. This provides a virtual frame
-     *      interval during which InputConsumer will collect raw events,
-     *      resample them and emit a "cooked" event back to us at roughly every
-     *      60th of a second. "cooked" events are both smoothed and
-     *      extrapolated/predicted into the future (for tool=finger) giving the
-     *      appearance of lower latency. Getting a real frame time from the
-     *      graphics logic (which is messy) does not appear to be necessary to
-     *      gain significant benefit.
-     *
-     * Note event_rate_hz is only 55Hz. This allows rendering to catch up and
-     * overtake the event rate every ~12th frame (200ms) on a 60Hz display.
-     * Thus on every 12th+1 frame, there will be zero buffer lag in responding
-     * to the cooked input event we have given the client.
-     * This phase control is useful as it eliminates the one frame of lag you
-     * would otherwise never catch up to if the event rate was exactly the same
-     * as the display refresh rate.
-     */
-
-    nsecs_t const now = android_clock(SYSTEM_TIME_MONOTONIC);
-    int const event_rate_hz = 55;
-    nsecs_t const one_frame = 1000000000ULL / event_rate_hz;
-    nsecs_t frame_time = (now / one_frame) * one_frame;
-
-    if (input_consumer->consume(&event_factory, true, frame_time,
-                                &event_sequence_id, &android_event)
-        == droidinput::OK)
+    droidinput::status_t status;
+
+    bool result = false;
+
+    if ((status = input_consumer->consume(&event_factory, true, has_new_frame_time ? frame_time : -1,
+        &event_sequence_id, &android_event))
+            == droidinput::OK)
     {
         mia::Lexicon::translate(android_event, ev);
-
         map_key_event(xkb_mapper, ev);
 
         input_consumer->sendFinishedSignal(event_sequence_id, true);
 
         report->received_event(ev);
 
-        return true;
+        result = true;
     }
-   return false;
+    
+    has_new_frame_time = false;
+
+    return result;
 }
 
 // TODO: We use a droidinput::Looper here for polling functionality but it might be nice to integrate
@@ -140,28 +122,22 @@
         looper->addFd(fd(), fd(), ALOOPER_EVENT_INPUT, nullptr, nullptr);
         fd_added = true;
     }
-
+    
     auto reduced_timeout = timeout;
-    if (input_consumer->hasDeferredEvent())
-    {
-        // consume() didn't finish last time. Retry it immediately.
-        reduced_timeout = std::chrono::milliseconds::zero();
-    }
-    else if (input_consumer->hasPendingBatch())
-    {
-        // When in constant motion we will usually "hasPendingBatch".
-        // But the batch won't get flushed until the next frame interval,
-        // so be sure to use a non-zero sleep time to avoid spinning the CPU
-        // for the whole interval...
-
-        // During tests with mocked clocks we may already have zero...
-        if (reduced_timeout != std::chrono::milliseconds::zero())
-            reduced_timeout = std::chrono::milliseconds(1);
-    }
-
-    auto result = looper->pollOnce(reduced_timeout.count());
-    if (result == ALOOPER_POLL_WAKE)
+    
+    if (input_consumer->hasPendingBatch())
+        reduced_timeout = std::chrono::milliseconds(1);
+
+    int result = 0;
+    if (!input_consumer->hasDeferredEvent())
+        result = looper->pollOnce(reduced_timeout.count());
+
+    std::lock_guard<std::mutex> lg(frame_time_guard);
+
+    // If we are awoken and not by a frame time it is for shutdown.
+    if (result == ALOOPER_POLL_WAKE && has_new_frame_time == false)
         return false;
+
     if (result == ALOOPER_POLL_ERROR) // TODO: Exception?
        return false;
 
@@ -172,3 +148,16 @@
 {
     looper->wake();
 }
+
+void mircva::InputReceiver::notify_of_frame_time(std::chrono::nanoseconds new_frame_time)
+{
+    {
+        std::lock_guard<std::mutex> lg(frame_time_guard);
+        has_new_frame_time = true;
+        if (new_frame_time != std::chrono::nanoseconds::min())
+            frame_time = new_frame_time.count();
+        else
+            frame_time = -1;
+    }
+    wake();
+}
 
=== modified file 'src/common/input/android/android_input_receiver.h'
--- src/common/input/android/android_input_receiver.h	2014-10-01 06:25:56 +0000
+++ src/common/input/android/android_input_receiver.h	2014-11-18 19:29:59 +0000
@@ -26,6 +26,7 @@
 
 #include <memory>
 #include <chrono>
+#include <mutex>
 
 namespace droidinput = android;
 
@@ -71,6 +72,8 @@
 
     /// May be used from any thread to wake an InputReceiver blocked in next_event
     virtual void wake();
+    
+    virtual void notify_of_frame_time(std::chrono::nanoseconds frame_time);
 
 protected:
     InputReceiver(const InputReceiver&) = delete;
@@ -89,6 +92,10 @@
     std::shared_ptr<XKBMapper> xkb_mapper;
 
     AndroidClock const android_clock;
+    
+    std::mutex frame_time_guard;
+    bool has_new_frame_time;
+    int64_t frame_time;
 
     bool try_next_event(MirEvent &ev);
 };
 
=== modified file 'src/common/input/android/android_input_receiver_thread.cpp'
--- src/common/input/android/android_input_receiver_thread.cpp	2013-05-13 23:20:52 +0000
+++ src/common/input/android/android_input_receiver_thread.cpp	2014-11-18 19:29:59 +0000
@@ -66,3 +66,8 @@
         std::this_thread::yield(); // yield() is needed to ensure reasonable runtime under valgrind
     }
 }
+
+void mircva::InputReceiverThread::notify_of_frame_time(std::chrono::nanoseconds frame_time)
+{
+    receiver->notify_of_frame_time(frame_time);
+}
 
=== modified file 'src/common/input/android/android_input_receiver_thread.h'
--- src/common/input/android/android_input_receiver_thread.h	2014-03-06 06:05:17 +0000
+++ src/common/input/android/android_input_receiver_thread.h	2014-11-18 19:29:59 +0000
@@ -49,6 +49,8 @@
     void start();
     void stop();
     void join();
+    
+    void notify_of_frame_time(std::chrono::nanoseconds frame_time) override;
 
 protected:
     InputReceiverThread(const InputReceiverThread&) = delete;
 
=== added directory 'src/include/platform/mir/frontend'
=== added file 'src/include/platform/mir/frontend/vsync_provider.h'
--- src/include/platform/mir/frontend/vsync_provider.h	1970-01-01 00:00:00 +0000
+++ src/include/platform/mir/frontend/vsync_provider.h	2014-11-18 19:29:59 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2014 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_FRONTEND_VSYNC_PROVIDER_H_
+#define MIR_FRONTEND_VSYNC_PROVIDER_H_
+
+#include "mir/graphics/display_configuration.h"
+
+#include <chrono>
+
+namespace mir
+{
+namespace frontend
+{
+class VsyncProvider
+{
+public:
+    virtual ~VsyncProvider() = default;
+    
+    virtual std::chrono::nanoseconds last_vsync_for(graphics::DisplayConfigurationOutputId output) = 0;
+
+protected:
+    VsyncProvider() = default;
+
+    VsyncProvider& operator=(VsyncProvider const& other) = delete;
+    VsyncProvider(VsyncProvider const& other) = delete;
+};
+}
+}
+
+#endif // MIR_FRONTEND_VSYNC_PROVIDER_H_
 
=== modified file 'src/platform/graphics/android/display.cpp'
--- src/platform/graphics/android/display.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/display.cpp	2014-11-18 19:29:59 +0000
@@ -22,6 +22,7 @@
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/gl_context.h"
 #include "mir/graphics/egl_resources.h"
+#include "hwc_vsync.h"
 #include "display.h"
 #include "display_builder.h"
 #include "mir/geometry/rectangle.h"
@@ -30,6 +31,7 @@
 
 namespace mga=mir::graphics::android;
 namespace mg=mir::graphics;
+namespace mf = mir::frontend;
 namespace geom=mir::geometry;
 
 mga::Display::Display(std::shared_ptr<mga::DisplayBuilder> const& display_builder,
@@ -110,3 +112,8 @@
 {
     return std::unique_ptr<mg::GLContext>{new mga::PbufferGLContext(gl_context)};
 }
+
+std::shared_ptr<mf::VsyncProvider> mga::Display::vsync_provider()
+{
+    return display_builder->vsync_coordinator();
+}
 
=== modified file 'src/platform/graphics/android/display.h'
--- src/platform/graphics/android/display.h	2014-11-03 06:51:26 +0000
+++ src/platform/graphics/android/display.h	2014-11-18 19:29:59 +0000
@@ -67,6 +67,8 @@
 
     std::shared_ptr<Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) override;
     std::unique_ptr<graphics::GLContext> create_gl_context() override;
+    std::shared_ptr<frontend::VsyncProvider> vsync_provider() override;
+
 
 private:
     std::shared_ptr<DisplayBuilder> const display_builder;
 
=== modified file 'src/platform/graphics/android/display_builder.h'
--- src/platform/graphics/android/display_builder.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/display_builder.h	2014-11-18 19:29:59 +0000
@@ -31,6 +31,7 @@
 namespace android
 {
 class GLContext;
+class HWCVsyncCoordinator;
 
 class DisplayBuilder
 {
@@ -41,6 +42,8 @@
     virtual std::unique_ptr<ConfigurableDisplayBuffer> create_display_buffer(
         GLProgramFactory const& gl_program_factory, GLContext const& gl_context) = 0;
 
+    virtual std::shared_ptr<HWCVsyncCoordinator> vsync_coordinator() const = 0;
+
 protected:
     DisplayBuilder() = default;
     DisplayBuilder(DisplayBuilder const&) = delete;
 
=== modified file 'src/platform/graphics/android/display_resource_factory.h'
--- src/platform/graphics/android/display_resource_factory.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/display_resource_factory.h	2014-11-18 19:29:59 +0000
@@ -35,6 +35,7 @@
 class DisplayDevice;
 class FramebufferBundle;
 class HwcWrapper;
+class HWCVsyncCoordinator;
 
 class DisplayResourceFactory
 {
@@ -54,6 +55,8 @@
     virtual std::shared_ptr<DisplayDevice> create_hwc_fb_device(
         std::shared_ptr<HwcWrapper> const& hwc_native_device,
         std::shared_ptr<framebuffer_device_t> const& fb_native_device) const = 0;
+    
+    virtual std::shared_ptr<HWCVsyncCoordinator> create_vsync_coordinator() const = 0;
 
 protected:
     DisplayResourceFactory() = default;
 
=== modified file 'src/platform/graphics/android/hwc_common_device.cpp'
--- src/platform/graphics/android/hwc_common_device.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_common_device.cpp	2014-11-18 19:29:59 +0000
@@ -32,12 +32,12 @@
 {
 }
 
-static void vsync_hook(const struct hwc_procs* procs, int /*disp*/, int64_t /*timestamp*/)
+static void vsync_hook(const struct hwc_procs* procs, int /*disp*/, int64_t timestamp)
 {
     auto self = reinterpret_cast<mga::HWCCallbacks const*>(procs)->self.load();
     if (!self)
         return;
-    self->notify_vsync();
+    self->notify_vsync(std::chrono::nanoseconds(timestamp));
 }
 
 static void hotplug_hook(const struct hwc_procs* /*procs*/, int /*disp*/, int /*connected*/)
@@ -84,9 +84,9 @@
     callbacks->self = nullptr;
 }
 
-void mga::HWCCommonDevice::notify_vsync()
+void mga::HWCCommonDevice::notify_vsync(std::chrono::nanoseconds timestamp)
 {
-    coordinator->notify_vsync();
+    coordinator->notify_vsync(timestamp);
 }
 
 void mga::HWCCommonDevice::mode(MirPowerMode mode_request)
 
=== modified file 'src/platform/graphics/android/hwc_common_device.h'
--- src/platform/graphics/android/hwc_common_device.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_common_device.h	2014-11-18 19:29:59 +0000
@@ -26,6 +26,7 @@
 #include <mutex>
 #include <condition_variable>
 #include <atomic>
+#include <chrono>
 
 namespace mir
 {
@@ -48,7 +49,7 @@
 public:
     virtual ~HWCCommonDevice() noexcept;
 
-    void notify_vsync();
+    void notify_vsync(std::chrono::nanoseconds timestamp);
     void mode(MirPowerMode mode);
     bool apply_orientation(MirOrientation orientation) const;
 
 
=== modified file 'src/platform/graphics/android/hwc_vsync.cpp'
--- src/platform/graphics/android/hwc_vsync.cpp	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/hwc_vsync.cpp	2014-11-18 19:29:59 +0000
@@ -17,10 +17,17 @@
  */
 
 #include "hwc_vsync.h"
-namespace mga=mir::graphics::android;
+
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
+
+namespace mg = mir::graphics;
+namespace mga = mg::android;
 
 mga::HWCVsync::HWCVsync()
-    : vsync_occurred(false)
+    : vsync_occurred(false),
+      last_vsync(std::chrono::nanoseconds::zero())
 {
 }
 
@@ -34,9 +41,24 @@
     }
 }
 
-void mga::HWCVsync::notify_vsync()
+void mga::HWCVsync::notify_vsync(std::chrono::nanoseconds time)
 {
     std::unique_lock<std::mutex> lk(vsync_wait_mutex);
+
     vsync_occurred = true;
+    last_vsync = time;
+
     vsync_trigger.notify_all();
 }
+
+std::chrono::nanoseconds mga::HWCVsync::last_vsync_for(mg::DisplayConfigurationOutputId output)
+{
+    if (output != mg::DisplayConfigurationOutputId{0})
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error(
+            "HWCVsync got non zero output ID but multi-monitor is not yet supported"));
+    }
+    
+    std::unique_lock<std::mutex> lk(vsync_wait_mutex);
+    return last_vsync;
+}
 
=== modified file 'src/platform/graphics/android/hwc_vsync.h'
--- src/platform/graphics/android/hwc_vsync.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/hwc_vsync.h	2014-11-18 19:29:59 +0000
@@ -19,9 +19,13 @@
 #ifndef MIR_GRAPHICS_ANDROID_HWC_VSYNC_H_
 #define MIR_GRAPHICS_ANDROID_HWC_VSYNC_H_
 
+#include "mir/frontend/vsync_provider.h"
+
 #include "hwc_vsync_coordinator.h"
+
 #include <mutex>
 #include <condition_variable>
+#include <chrono>
 
 namespace mir
 {
@@ -36,11 +40,16 @@
     HWCVsync();
 
     void wait_for_vsync();
-    void notify_vsync();
+    void notify_vsync(std::chrono::nanoseconds time);
+    
+    std::chrono::nanoseconds last_vsync_for(graphics::DisplayConfigurationOutputId output) override;    
+
 private:
     std::mutex vsync_wait_mutex;
     std::condition_variable vsync_trigger;
+
     bool vsync_occurred;
+    std::chrono::nanoseconds last_vsync;
 };
 
 }
 
=== modified file 'src/platform/graphics/android/hwc_vsync_coordinator.h'
--- src/platform/graphics/android/hwc_vsync_coordinator.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/hwc_vsync_coordinator.h	2014-11-18 19:29:59 +0000
@@ -19,6 +19,10 @@
 #ifndef MIR_GRAPHICS_ANDROID_HWC_VSYNC_COORDINATOR_H_
 #define MIR_GRAPHICS_ANDROID_HWC_VSYNC_COORDINATOR_H_
 
+#include "mir/frontend/vsync_provider.h"
+
+#include <chrono>
+
 namespace mir
 {
 namespace graphics
@@ -26,13 +30,14 @@
 namespace android
 {
 
-class HWCVsyncCoordinator
+class HWCVsyncCoordinator : public frontend::VsyncProvider
 {
 public:
     virtual ~HWCVsyncCoordinator() = default;
 
     virtual void wait_for_vsync() = 0;
-    virtual void notify_vsync() = 0;
+    virtual void notify_vsync(std::chrono::nanoseconds time) = 0;
+    virtual std::chrono::nanoseconds last_vsync_for(DisplayConfigurationOutputId id) = 0;
 
 protected:
     HWCVsyncCoordinator() = default;
 
=== modified file 'src/platform/graphics/android/output_builder.cpp'
--- src/platform/graphics/android/output_builder.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/output_builder.cpp	2014-11-18 19:29:59 +0000
@@ -41,6 +41,7 @@
     : buffer_allocator(buffer_allocator),
       res_factory(res_factory),
       display_report(display_report),
+      vsync_coordinator_(res_factory->create_vsync_coordinator()),
       force_backup_display(false),
       overlay_optimization(overlay_optimization)
 {
@@ -118,3 +119,8 @@
         gl_program_factory,
         overlay_optimization));
 }
+
+std::shared_ptr<mga::HWCVsyncCoordinator> mga::OutputBuilder::vsync_coordinator() const
+{
+    return vsync_coordinator_;
+}
 
=== modified file 'src/platform/graphics/android/output_builder.h'
--- src/platform/graphics/android/output_builder.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/output_builder.h	2014-11-18 19:29:59 +0000
@@ -52,11 +52,13 @@
     std::unique_ptr<ConfigurableDisplayBuffer> create_display_buffer(
         GLProgramFactory const& gl_program_factory,
         GLContext const& gl_context);
+    std::shared_ptr<HWCVsyncCoordinator> vsync_coordinator() const;
 
 private:
     std::shared_ptr<GraphicBufferAllocator> const buffer_allocator;
     std::shared_ptr<DisplayResourceFactory> const res_factory;
     std::shared_ptr<DisplayReport> const display_report;
+    std::shared_ptr<HWCVsyncCoordinator> const vsync_coordinator_;
 
     std::shared_ptr<FramebufferBundle> framebuffers;
     bool force_backup_display;
 
=== modified file 'src/platform/graphics/android/platform.cpp'
--- src/platform/graphics/android/platform.cpp	2014-11-18 03:21:20 +0000
+++ src/platform/graphics/android/platform.cpp	2014-11-18 19:29:59 +0000
@@ -26,6 +26,7 @@
 #include "output_builder.h"
 #include "buffer_writer.h"
 #include "hwc_loggers.h"
+#include "hwc_vsync.h"
 #include "ipc_operations.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/buffer_ipc_message.h"
@@ -160,6 +161,7 @@
     auto logger = make_logger(*options);
     auto overlay_option = should_use_overlay_optimization(*options);
     logger->log_overlay_optimization(overlay_option);
+
     auto display_resource_factory = std::make_shared<mga::ResourceFactory>();
     auto fb_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>();
     auto display_builder = std::make_shared<mga::OutputBuilder>(
@@ -172,7 +174,8 @@
     std::shared_ptr<mg::NestedContext> const&)
 {
     //TODO: remove nullptr parameter once platform classes are sorted.
-    //      mg::NativePlatform cannot create a display anyways, so it doesnt need a  display builder
+    //      mg::NativePlatform cannot create a display anyways, so it doesnt need a  display builder or
+    //      a vsync provider.
     return std::make_shared<mga::Platform>(nullptr, display_report);
 }
 
 
=== modified file 'src/platform/graphics/android/platform.h'
--- src/platform/graphics/android/platform.h	2014-11-18 03:21:20 +0000
+++ src/platform/graphics/android/platform.h	2014-11-18 19:29:59 +0000
@@ -33,6 +33,7 @@
 class GraphicBufferAllocator;
 class FramebufferFactory;
 class DisplayBuilder;
+class HWCVsyncCoordinator;
 
 class Platform : public graphics::Platform, public NativePlatform
 {
@@ -52,6 +53,7 @@
     std::shared_ptr<PlatformIPCPackage> connection_ipc_package() override;
     std::shared_ptr<InternalClient> create_internal_client() override;
     std::shared_ptr<graphics::BufferWriter> make_buffer_writer() override;
+
     void fill_buffer_package(
         BufferIpcMessage* packer, graphics::Buffer const* buffer, BufferIpcMsgType msg_type) const override;
     EGLNativeDisplayType egl_native_display() const override;
@@ -63,6 +65,7 @@
 
     std::shared_ptr<DisplayBuilder> const display_builder;
     std::shared_ptr<DisplayReport> const display_report;
+
     std::shared_ptr<PlatformIpcOperations> const ipc_operations;
     DeviceQuirks quirks{PropertiesOps{}};
 };
 
=== modified file 'src/platform/graphics/android/resource_factory.cpp'
--- src/platform/graphics/android/resource_factory.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/resource_factory.cpp	2014-11-18 19:29:59 +0000
@@ -39,6 +39,11 @@
 namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 
+mga::ResourceFactory::ResourceFactory()
+    : vsync_coordinator(std::make_shared<mga::HWCVsync>())
+{
+}
+
 std::shared_ptr<framebuffer_device_t> mga::ResourceFactory::create_fb_native_device() const
 {
     hw_module_t const* module;
@@ -92,15 +97,18 @@
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc_device(
     std::shared_ptr<HwcWrapper> const& wrapper) const
 {
-    auto syncer = std::make_shared<mga::HWCVsync>();
     auto file_ops = std::make_shared<mga::RealSyncFileOps>();
-    return std::make_shared<mga::HwcDevice>(wrapper, syncer, file_ops);
+    return std::make_shared<mga::HwcDevice>(wrapper, vsync_coordinator, file_ops);
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc_fb_device(
     std::shared_ptr<HwcWrapper> const& wrapper,
     std::shared_ptr<framebuffer_device_t> const& fb_native_device) const
 {
-    auto syncer = std::make_shared<mga::HWCVsync>();
-    return std::make_shared<mga::HwcFbDevice>(wrapper, fb_native_device, syncer);
+    return std::make_shared<mga::HwcFbDevice>(wrapper, fb_native_device, vsync_coordinator);
+}
+
+std::shared_ptr<mga::HWCVsyncCoordinator> mga::ResourceFactory::create_vsync_coordinator() const
+{
+    return vsync_coordinator;
 }
 
=== modified file 'src/platform/graphics/android/resource_factory.h'
--- src/platform/graphics/android/resource_factory.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/resource_factory.h	2014-11-18 19:29:59 +0000
@@ -27,10 +27,12 @@
 {
 namespace android
 {
+class HWCVsyncCoordinator;
 
 class ResourceFactory : public DisplayResourceFactory
 {
 public:
+    ResourceFactory();
     //native allocations
     std::shared_ptr<hwc_composer_device_1> create_hwc_native_device() const;
     std::shared_ptr<framebuffer_device_t> create_fb_native_device() const;
@@ -46,6 +48,11 @@
 
     std::shared_ptr<ANativeWindow> create_native_window(
         std::shared_ptr<FramebufferBundle> const& fb_bundle) const;
+    
+    std::shared_ptr<HWCVsyncCoordinator> create_vsync_coordinator() const;
+
+private:
+    std::shared_ptr<HWCVsyncCoordinator> const vsync_coordinator;
 };
 
 }
 
=== modified file 'src/platform/graphics/mesa/display.cpp'
--- src/platform/graphics/mesa/display.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/mesa/display.cpp	2014-11-18 19:29:59 +0000
@@ -24,12 +24,15 @@
 #include "kms_output.h"
 #include "kms_page_flipper.h"
 #include "virtual_terminal.h"
+
 #include "mir/graphics/overlapping_output_grouping.h"
 #include "mir/graphics/event_handler_register.h"
-
 #include "mir/graphics/display_report.h"
 #include "mir/graphics/gl_context.h"
 #include "mir/graphics/display_configuration_policy.h"
+
+#include "mir/frontend/vsync_provider.h"
+
 #include "mir/geometry/rectangle.h"
 
 #include <boost/throw_exception.hpp>
@@ -41,6 +44,7 @@
 
 namespace mgm = mir::graphics::mesa;
 namespace mg = mir::graphics;
+namespace mf = mir::frontend;
 namespace geom = mir::geometry;
 
 namespace
@@ -360,3 +364,16 @@
         }
     });
 }
+
+// TODO: Implement for Mesa to enable touch resampling
+std::shared_ptr<mf::VsyncProvider> mgm::Display::vsync_provider()
+{
+    struct NullVsyncProvider : public mf::VsyncProvider
+    {
+        std::chrono::nanoseconds last_vsync_for(graphics::DisplayConfigurationOutputId) override
+        {
+            return std::chrono::nanoseconds::zero();
+        }
+    };
+    return std::make_shared<NullVsyncProvider>();
+}
 
=== modified file 'src/platform/graphics/mesa/display.h'
--- src/platform/graphics/mesa/display.h	2014-11-03 06:51:26 +0000
+++ src/platform/graphics/mesa/display.h	2014-11-18 19:29:59 +0000
@@ -81,6 +81,8 @@
 
     std::shared_ptr<graphics::Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) override;
     std::unique_ptr<GLContext> create_gl_context() override;
+    std::shared_ptr<frontend::VsyncProvider> vsync_provider() override;
+
 
 private:
     void clear_connected_unused_outputs();
 
=== modified file 'src/protobuf/mir_protobuf.proto'
--- src/protobuf/mir_protobuf.proto	2014-10-27 22:31:16 +0000
+++ src/protobuf/mir_protobuf.proto	2014-11-18 19:29:59 +0000
@@ -39,6 +39,8 @@
   optional uint32 flags = 6;
   optional int32  width = 7;
   optional int32  height = 8;
+  
+  optional int64  vsync_time = 9;
 
   optional string error = 127;
 }
 
=== modified file 'src/server/frontend/default_configuration.cpp'
--- src/server/frontend/default_configuration.cpp	2014-11-12 14:07:30 +0000
+++ src/server/frontend/default_configuration.cpp	2014-11-18 19:29:59 +0000
@@ -27,6 +27,7 @@
 #include "mir/graphics/platform.h"
 #include "mir/frontend/protobuf_connection_creator.h"
 #include "mir/frontend/session_authorizer.h"
+#include "mir/graphics/display.h"
 #include "mir/options/configuration.h"
 #include "mir/options/option.h"
 
@@ -137,6 +138,16 @@
         });
 }
 
+std::shared_ptr<mf::VsyncProvider>
+mir::DefaultServerConfiguration::the_vsync_provider()
+{
+    return vsync_provider(
+        [&]()
+        {
+            return the_display()->vsync_provider();
+        });
+}
+
 std::shared_ptr<mir::frontend::ProtobufIpcFactory>
 mir::DefaultServerConfiguration::new_ipc_factory(
     std::shared_ptr<mf::SessionAuthorizer> const& session_authorizer)
@@ -151,13 +162,14 @@
         translator = std::make_shared<mf::UnsupportedCoordinateTranslator>();
     }
     return std::make_shared<mf::DefaultIpcFactory>(
-                the_frontend_shell(),
-                the_session_mediator_report(),
-                the_graphics_platform()->make_ipc_operations(),
-                the_frontend_display_changer(),
-                the_buffer_allocator(),
-                the_screencast(),
-                session_authorizer,
-                the_cursor_images(),
-                translator);
+        the_frontend_shell(),
+        the_session_mediator_report(),
+        the_graphics_platform()->make_ipc_operations(),
+        the_frontend_display_changer(),
+        the_buffer_allocator(),
+        the_screencast(),
+        session_authorizer,
+        the_cursor_images(),
+        the_vsync_provider(),
+        translator);
 }
 
=== modified file 'src/server/frontend/default_ipc_factory.cpp'
--- src/server/frontend/default_ipc_factory.cpp	2014-11-12 14:07:30 +0000
+++ src/server/frontend/default_ipc_factory.cpp	2014-11-18 19:29:59 +0000
@@ -39,6 +39,7 @@
     std::shared_ptr<Screencast> const& screencast,
     std::shared_ptr<SessionAuthorizer> const& session_authorizer,
     std::shared_ptr<mi::CursorImages> const& cursor_images,
+    std::shared_ptr<mf::VsyncProvider> const& vsync_provider,
     std::shared_ptr<scene::CoordinateTranslator> const& translator) :
     shell(shell),
     no_prompt_shell(std::make_shared<NoPromptShell>(shell)),
@@ -50,6 +51,7 @@
     screencast(screencast),
     session_authorizer(session_authorizer),
     cursor_images(cursor_images),
+    vsync_provider(vsync_provider),
     translator{translator}
 {
 }
@@ -93,7 +95,7 @@
         sm_report,
         sink,
         effective_screencast,
-        connection_context, cursor_images);
+        connection_context, cursor_images, vsync_provider);
 }
 
 std::shared_ptr<mf::ResourceCache> mf::DefaultIpcFactory::resource_cache()
@@ -110,7 +112,8 @@
     std::shared_ptr<EventSink> const& sink,
     std::shared_ptr<Screencast> const& effective_screencast,
     ConnectionContext const& connection_context,
-    std::shared_ptr<mi::CursorImages> const& cursor_images)
+    std::shared_ptr<mi::CursorImages> const& cursor_images,
+    std::shared_ptr<mf::VsyncProvider> const& vsync_provider)
 {
     return std::make_shared<SessionMediator>(
         shell,
@@ -123,5 +126,6 @@
         effective_screencast,
         connection_context,
         cursor_images,
+        vsync_provider,
         translator);
 }
 
=== modified file 'src/server/frontend/default_ipc_factory.h'
--- src/server/frontend/default_ipc_factory.h	2014-11-12 14:07:30 +0000
+++ src/server/frontend/default_ipc_factory.h	2014-11-18 19:29:59 +0000
@@ -45,6 +45,7 @@
 class DisplayChanger;
 class Screencast;
 class SessionAuthorizer;
+class VsyncProvider;
 
 class DefaultIpcFactory : public ProtobufIpcFactory
 {
@@ -58,6 +59,7 @@
         std::shared_ptr<Screencast> const& screencast,
         std::shared_ptr<SessionAuthorizer> const& session_authorizer,
         std::shared_ptr<input::CursorImages> const& cursor_images,
+        std::shared_ptr<VsyncProvider> const& vsync_provider,
         std::shared_ptr<scene::CoordinateTranslator> const& translator);
 
     std::shared_ptr<detail::DisplayServer> make_ipc_server(
@@ -76,7 +78,8 @@
         std::shared_ptr<EventSink> const& sink,
         std::shared_ptr<Screencast> const& effective_screencast,
         ConnectionContext const& connection_context,
-        std::shared_ptr<input::CursorImages> const& cursor_images);
+        std::shared_ptr<input::CursorImages> const& cursor_images,
+        std::shared_ptr<VsyncProvider> const& vsync_provider);
 
 private:
     std::shared_ptr<Shell> const shell;
@@ -89,6 +92,7 @@
     std::shared_ptr<Screencast> const screencast;
     std::shared_ptr<SessionAuthorizer> const session_authorizer;
     std::shared_ptr<input::CursorImages> const cursor_images;
+    std::shared_ptr<frontend::VsyncProvider> const vsync_provider;
     std::shared_ptr<scene::CoordinateTranslator> const translator;
 };
 }
 
=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2014-11-18 03:21:20 +0000
+++ src/server/frontend/session_mediator.cpp	2014-11-18 19:29:59 +0000
@@ -41,6 +41,7 @@
 #include "mir/frontend/event_sink.h"
 #include "mir/frontend/screencast.h"
 #include "mir/frontend/prompt_session.h"
+#include "mir/frontend/vsync_provider.h"
 #include "mir/scene/prompt_session_creation_parameters.h"
 #include "mir/fd.h"
 
@@ -74,6 +75,7 @@
     std::shared_ptr<Screencast> const& screencast,
     ConnectionContext const& connection_context,
     std::shared_ptr<mi::CursorImages> const& cursor_images,
+    std::shared_ptr<mf::VsyncProvider> const& vsync_provider,
     std::shared_ptr<scene::CoordinateTranslator> const& translator) :
     client_pid_(0),
     shell(shell),
@@ -86,6 +88,7 @@
     screencast(screencast),
     connection_context(connection_context),
     cursor_images(cursor_images),
+    vsync_provider(vsync_provider),
     translator{translator},
     surface_tracker{static_cast<size_t>(client_buffer_cache_size)}
 {
@@ -671,6 +674,11 @@
 {
     protobuf_buffer.set_buffer_id(graphics_buffer->id().as_value());
 
+    // TODO: ~racarr Enable MM touch resampling
+    auto vsync_time = vsync_provider->last_vsync_for(mg::DisplayConfigurationOutputId{0});
+    if (vsync_time != std::chrono::nanoseconds::zero())
+        protobuf_buffer.set_vsync_time(vsync_time.count());
+
     mfd::ProtobufBufferPacker packer{&protobuf_buffer};
     ipc_operations->pack_buffer(packer, *graphics_buffer, buffer_msg_type);
 
 
=== modified file 'src/server/frontend/session_mediator.h'
--- src/server/frontend/session_mediator.h	2014-11-12 14:07:30 +0000
+++ src/server/frontend/session_mediator.h	2014-11-18 19:29:59 +0000
@@ -63,6 +63,7 @@
 class DisplayChanger;
 class Screencast;
 class PromptSession;
+class VsyncProvider;
 
 // SessionMediator relays requests from the client process into the server.
 class SessionMediator : public detail::DisplayServer, public mir::protobuf::Debug
@@ -80,6 +81,7 @@
         std::shared_ptr<Screencast> const& screencast,
         ConnectionContext const& connection_context,
         std::shared_ptr<input::CursorImages> const& cursor_images,
+        std::shared_ptr<VsyncProvider> const& vsync_provider,
         std::shared_ptr<scene::CoordinateTranslator> const& translator);
 
     ~SessionMediator() noexcept;
@@ -203,6 +205,7 @@
     std::shared_ptr<Screencast> const screencast;
     ConnectionContext const connection_context;
     std::shared_ptr<input::CursorImages> const cursor_images;
+    std::shared_ptr<frontend::VsyncProvider> const vsync_provider;
     std::shared_ptr<scene::CoordinateTranslator> const translator;
 
     SurfaceTracker surface_tracker;
 
=== modified file 'src/server/graphics/nested/CMakeLists.txt'
--- src/server/graphics/nested/CMakeLists.txt	2014-10-01 06:25:56 +0000
+++ src/server/graphics/nested/CMakeLists.txt	2014-11-18 19:29:59 +0000
@@ -9,6 +9,7 @@
   nested_display_configuration.cpp
   nested_output.cpp
   nested_platform.cpp
+  nested_vsync_provider.cpp
   mir_client_host_connection.cpp
 )
 
 
=== modified file 'src/server/graphics/nested/host_connection.h'
--- src/server/graphics/nested/host_connection.h	2014-04-24 08:42:12 +0000
+++ src/server/graphics/nested/host_connection.h	2014-11-18 19:29:59 +0000
@@ -24,6 +24,7 @@
 #include <memory>
 #include <vector>
 #include <functional>
+#include <chrono>
 
 #include <EGL/egl.h>
 
@@ -43,6 +44,8 @@
 
     virtual EGLNativeWindowType egl_native_window() = 0;
     virtual void set_event_handler(MirEventDelegate const* handler) = 0;
+    
+    virtual std::chrono::nanoseconds last_display_time() = 0;
 
 protected:
     HostSurface() = default;
 
=== modified file 'src/server/graphics/nested/mir_client_host_connection.cpp'
--- src/server/graphics/nested/mir_client_host_connection.cpp	2014-10-01 06:25:56 +0000
+++ src/server/graphics/nested/mir_client_host_connection.cpp	2014-11-18 19:29:59 +0000
@@ -77,6 +77,11 @@
     {
         mir_surface_set_event_handler(mir_surface, handler);
     }
+    
+    std::chrono::nanoseconds last_display_time() override
+    {
+        return std::chrono::nanoseconds(mir_surface_get_last_display_time(mir_surface));
+    }
 
 private:
     MirSurface* const mir_surface;
 
=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2014-10-01 06:25:56 +0000
+++ src/server/graphics/nested/nested_display.cpp	2014-11-18 19:29:59 +0000
@@ -19,6 +19,7 @@
 #include "nested_display.h"
 #include "nested_display_configuration.h"
 #include "nested_output.h"
+#include "nested_vsync_provider.h"
 #include "host_connection.h"
 
 #include "mir/geometry/rectangle.h"
@@ -34,6 +35,7 @@
 
 namespace mg = mir::graphics;
 namespace mgn = mir::graphics::nested;
+namespace mf = mir::frontend;
 namespace geom = mir::geometry;
 
 EGLint const mgn::detail::nested_egl_context_attribs[] =
@@ -131,6 +133,7 @@
     dispatcher{dispatcher},
     display_report{display_report},
     egl_display{connection->egl_native_display(), gl_config},
+    vsync_provider_(std::make_shared<mgn::VsyncProvider>()),
     outputs{}
 {
     std::shared_ptr<DisplayConfiguration> conf(configuration());
@@ -211,7 +214,7 @@
                             host_surface,
                             area,
                             dispatcher,
-                            output.current_format);
+                            output.current_format, vsync_provider_, output.id);
                         have_output_for_group = true;
                     }
                 });
@@ -267,3 +270,8 @@
 {
     return std::unique_ptr<mg::GLContext>{new SurfacelessEGLContext(egl_display, EGL_NO_CONTEXT)};
 }
+
+std::shared_ptr<mf::VsyncProvider> mgn::NestedDisplay::vsync_provider()
+{
+    return vsync_provider_;
+}
 
=== modified file 'src/server/graphics/nested/nested_display.h'
--- src/server/graphics/nested/nested_display.h	2014-10-01 06:25:56 +0000
+++ src/server/graphics/nested/nested_display.h	2014-11-18 19:29:59 +0000
@@ -48,6 +48,7 @@
 
 namespace nested
 {
+class VsyncProvider;
 namespace detail
 {
 
@@ -124,6 +125,8 @@
 
     std::shared_ptr<Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) override;
     std::unique_ptr<graphics::GLContext> create_gl_context() override;
+    
+    std::shared_ptr<frontend::VsyncProvider> vsync_provider() override;
 
 private:
     std::shared_ptr<Platform> const platform;
@@ -131,6 +134,7 @@
     std::shared_ptr<input::InputDispatcher> const dispatcher;
     std::shared_ptr<DisplayReport> const display_report;
     detail::EGLDisplayHandle egl_display;
+    std::shared_ptr<VsyncProvider> const vsync_provider_;
 
     std::mutex outputs_mutex;
     std::unordered_map<DisplayConfigurationOutputId, std::shared_ptr<detail::NestedOutput>> outputs;
 
=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2014-10-01 06:25:56 +0000
+++ src/server/graphics/nested/nested_output.cpp	2014-11-18 19:29:59 +0000
@@ -18,6 +18,8 @@
 
 #include "nested_output.h"
 #include "host_connection.h"
+#include "nested_vsync_provider.h"
+
 #include "mir/input/input_dispatcher.h"
 #include "mir/graphics/pixel_format_utils.h"
 
@@ -33,7 +35,9 @@
     std::shared_ptr<HostSurface> const& host_surface,
     geometry::Rectangle const& area,
     std::shared_ptr<input::InputDispatcher> const& dispatcher,
-    MirPixelFormat preferred_format) :
+    MirPixelFormat preferred_format,
+    std::shared_ptr<mgn::VsyncProvider> const& vsync_provider,
+    mg::DisplayConfigurationOutputId id) :
     uses_alpha_{mg::contains_alpha(preferred_format)},
     egl_display(egl_display),
     host_surface{host_surface},
@@ -41,7 +45,9 @@
     egl_context{egl_display, eglCreateContext(egl_display, egl_config, egl_display.egl_context(), nested_egl_context_attribs)},
     area{area.top_left, area.size},
     dispatcher{dispatcher},
-    egl_surface{egl_display, host_surface->egl_native_window(), egl_config}
+    egl_surface{egl_display, host_surface->egl_native_window(), egl_config},
+    vsync_provider(vsync_provider),
+    id(id)
 {
     MirEventDelegate ed = {event_thunk, this};
     host_surface->set_event_handler(&ed);
@@ -66,6 +72,7 @@
 void mgn::detail::NestedOutput::post_update()
 {
     eglSwapBuffers(egl_display, egl_surface);
+    vsync_provider->notify_of_vsync(id, host_surface->last_display_time());
 }
 
 bool mgn::detail::NestedOutput::post_renderables_if_optimizable(RenderableList const&)
 
=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2014-11-03 06:51:26 +0000
+++ src/server/graphics/nested/nested_output.h	2014-11-18 19:29:59 +0000
@@ -21,6 +21,8 @@
 
 #include "nested_display.h"
 
+#include "mir/graphics/display_configuration.h"
+
 namespace mir
 {
 namespace graphics
@@ -28,6 +30,7 @@
 namespace nested
 {
 class HostSurface;
+class VsyncProvider;
 
 namespace detail
 {
@@ -40,7 +43,9 @@
         std::shared_ptr<HostSurface> const& host_surface,
         geometry::Rectangle const& area,
         std::shared_ptr<input::InputDispatcher> const& input_dispatcher,
-        MirPixelFormat preferred_format);
+        MirPixelFormat preferred_format,
+        std::shared_ptr<VsyncProvider> const& vsync_provider,
+        DisplayConfigurationOutputId id);
 
     ~NestedOutput() noexcept;
 
@@ -64,6 +69,9 @@
     geometry::Rectangle const area;
     std::shared_ptr<input::InputDispatcher> const dispatcher;
     EGLSurfaceHandle const egl_surface;
+    
+    std::shared_ptr<VsyncProvider> const vsync_provider;
+    DisplayConfigurationOutputId id;
 
     static void event_thunk(MirSurface* surface, MirEvent const* event, void* context);
     void mir_event(MirEvent const& event);
 
=== modified file 'src/server/graphics/nested/nested_platform.cpp'
--- src/server/graphics/nested/nested_platform.cpp	2014-11-18 09:59:21 +0000
+++ src/server/graphics/nested/nested_platform.cpp	2014-11-18 19:29:59 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "nested_platform.h"
+#include "nested_vsync_provider.h"
 #include "host_connection.h"
 #include "mir/graphics/nested_context.h"
 
@@ -24,6 +25,7 @@
 
 namespace mg = mir::graphics;
 namespace mgn = mir::graphics::nested;
+namespace mf = mir::frontend;
 
 mgn::NestedPlatform::NestedPlatform(
     std::shared_ptr<HostConnection> const& connection,
 
=== added file 'src/server/graphics/nested/nested_vsync_provider.cpp'
--- src/server/graphics/nested/nested_vsync_provider.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/nested/nested_vsync_provider.cpp	2014-11-18 19:29:59 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "nested_vsync_provider.h"
+
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace mg = mir::graphics;
+namespace mgn = mg::nested;
+
+void mgn::VsyncProvider::notify_of_vsync(mg::DisplayConfigurationOutputId id, std::chrono::nanoseconds vsync_time)
+{
+    std::lock_guard<std::mutex> lg(last_vsync_guard);
+    last_vsync[id] = vsync_time;
+}
+
+std::chrono::nanoseconds mgn::VsyncProvider::last_vsync_for(mg::DisplayConfigurationOutputId id)
+{
+    std::lock_guard<std::mutex> lg(last_vsync_guard);
+    
+    // In this structure we see two flaws of the DisplayConfigurationOutputId mechanism
+    // 1. Failure to find id is not an exception, we may have just not seen a vsync time yet
+    // how do we differentiate without complex integration with display notification changes?
+    // 2. Similarly, how do we know when we are done with an ID?
+    if (last_vsync.find(id) == last_vsync.end())
+        return std::chrono::nanoseconds::zero();
+    
+    return last_vsync[id];
+}
 
=== added file 'src/server/graphics/nested/nested_vsync_provider.h'
--- src/server/graphics/nested/nested_vsync_provider.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/nested/nested_vsync_provider.h	2014-11-18 19:29:59 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_NESTED_VSYNC_PROVIDER_H_
+#define MIR_GRAPHICS_NESTED_VSYNC_PROVIDER_H_
+
+#include "mir/frontend/vsync_provider.h"
+
+#include <mutex>
+#include <map>
+
+namespace mir
+{
+namespace graphics
+{
+namespace nested
+{
+
+struct VsyncProvider : public frontend::VsyncProvider
+{
+public:
+    void notify_of_vsync(DisplayConfigurationOutputId id, std::chrono::nanoseconds vsync_time);
+    std::chrono::nanoseconds last_vsync_for(DisplayConfigurationOutputId id);
+    
+private:
+    std::mutex last_vsync_guard;
+    std::map<DisplayConfigurationOutputId, std::chrono::nanoseconds> last_vsync;
+};
+
+}
+}
+}
+
+#endif // MIR_GRAPHICS_NESTED_VSYNC_PROVIDER_H_
 
=== modified file 'src/server/graphics/offscreen/display.cpp'
--- src/server/graphics/offscreen/display.cpp	2014-10-01 06:25:56 +0000
+++ src/server/graphics/offscreen/display.cpp	2014-11-18 19:29:59 +0000
@@ -20,12 +20,14 @@
 #include "display_buffer.h"
 #include "mir/graphics/basic_platform.h"
 #include "mir/graphics/display_configuration_policy.h"
+#include "mir/frontend/vsync_provider.h"
 #include "mir/geometry/size.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
 namespace mg = mir::graphics;
+namespace mf = mir::frontend;
 namespace mgo = mg::offscreen;
 namespace geom = mir::geometry;
 
@@ -173,3 +175,17 @@
     return std::unique_ptr<GLContext>{
         new SurfacelessEGLContext{egl_display, egl_context_shared}};
 }
+
+// Not many examples of needing interactive touch resampling to offscreen outputs
+// so this may never have an implementation...perhaps leaving some code smell.
+std::shared_ptr<mf::VsyncProvider> mgo::Display::vsync_provider()
+{
+    struct NullVsyncProvider : public mf::VsyncProvider
+    {
+        std::chrono::nanoseconds last_vsync_for(graphics::DisplayConfigurationOutputId) override
+        {
+            return std::chrono::nanoseconds::zero();
+        }
+    };
+    return std::make_shared<NullVsyncProvider>();
+}
 
=== modified file 'src/server/graphics/offscreen/display.h'
--- src/server/graphics/offscreen/display.h	2014-11-03 06:51:26 +0000
+++ src/server/graphics/offscreen/display.h	2014-11-18 19:29:59 +0000
@@ -88,6 +88,8 @@
 
     std::shared_ptr<Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) override;
     std::unique_ptr<GLContext> create_gl_context() override;
+    std::shared_ptr<frontend::VsyncProvider> vsync_provider() override;
+
 
 private:
     std::shared_ptr<BasicPlatform> const basic_platform;
 
=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2014-11-18 17:26:29 +0000
+++ src/server/symbols.map	2014-11-18 19:29:59 +0000
@@ -103,6 +103,7 @@
     mir::DefaultServerConfiguration::the_scene*;
     mir::DefaultServerConfiguration::the_scene_report*;
     mir::DefaultServerConfiguration::the_screencast*;
+    mir::DefaultServerConfiguration::the_vsync_provider*;
     mir::DefaultServerConfiguration::the_server_action_queue*;
     mir::DefaultServerConfiguration::the_server_status_listener*;
     mir::DefaultServerConfiguration::the_session_authorizer*;
@@ -578,6 +579,7 @@
     non-virtual?thunk?to?mir::DefaultServerConfiguration::the_scene*;
     non-virtual?thunk?to?mir::DefaultServerConfiguration::the_scene_report*;
     non-virtual?thunk?to?mir::DefaultServerConfiguration::the_screencast*;
+    non-virtual?thunk?to?mir::DefaultServerConfiguration::the_vsync_provider*;
     non-virtual?thunk?to?mir::DefaultServerConfiguration::the_server_action_queue*;
     non-virtual?thunk?to?mir::DefaultServerConfiguration::the_server_status_listener*;
     non-virtual?thunk?to?mir::DefaultServerConfiguration::the_session_authorizer*;
 
=== modified file 'tests/acceptance-tests/test_client_library.cpp'
--- tests/acceptance-tests/test_client_library.cpp	2014-11-11 17:46:49 +0000
+++ tests/acceptance-tests/test_client_library.cpp	2014-11-18 19:29:59 +0000
@@ -146,11 +146,16 @@
         }
     }
 };
+    
+struct ClientLibraryStubbedPlatform : public ClientLibrary
+{
+    mtf::UsingStubClientPlatform using_stub_client_platform;
+};
 }
 
 using namespace testing;
 
-TEST_F(ClientLibrary, client_library_connects_and_disconnects)
+TEST_F(ClientLibraryStubbedPlatform, client_library_connects_and_disconnects)
 {
     MirWaitHandle* wh = mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this);
     EXPECT_THAT(wh, NotNull());
@@ -163,7 +168,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, synchronous_connection)
+TEST_F(ClientLibraryStubbedPlatform, synchronous_connection)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -174,7 +179,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, creates_surface)
+TEST_F(ClientLibraryStubbedPlatform, creates_surface)
 {
     mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
 
@@ -220,7 +225,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, can_set_surface_types)
+TEST_F(ClientLibraryStubbedPlatform, can_set_surface_types)
 {
     mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
 
@@ -265,7 +270,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, can_set_surface_state)
+TEST_F(ClientLibraryStubbedPlatform, can_set_surface_state)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -307,7 +312,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, receives_surface_dpi_value)
+TEST_F(ClientLibraryStubbedPlatform, receives_surface_dpi_value)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -388,7 +393,7 @@
 
 #ifdef ANDROID
 // Mir's Android test infrastructure isn't quite ready for this yet.
-TEST_F(ClientLibrary, DISABLED_gets_buffer_dimensions)
+TEST_F(ClientLibraryStubbedPlatform, DISABLED_gets_buffer_dimensions)
 #else
 TEST_F(ClientLibrary, gets_buffer_dimensions)
 #endif
@@ -436,7 +441,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, creates_multiple_surfaces)
+TEST_F(ClientLibraryStubbedPlatform, creates_multiple_surfaces)
 {
     int const n_surfaces = 13;
     size_t old_surface_count = 0;
@@ -475,7 +480,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, client_library_accesses_and_advances_buffers)
+TEST_F(ClientLibraryStubbedPlatform, client_library_accesses_and_advances_buffers)
 {
     mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
 
@@ -501,7 +506,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, fully_synchronous_client)
+TEST_F(ClientLibraryStubbedPlatform, fully_synchronous_client)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -527,7 +532,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, highly_threaded_client)
+TEST_F(ClientLibraryStubbedPlatform, highly_threaded_client)
 {
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -560,7 +565,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, accesses_platform_package)
+TEST_F(ClientLibraryStubbedPlatform, accesses_platform_package)
 {
     mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
 
@@ -575,7 +580,7 @@
     mir_connection_release(connection);
 }
 
-TEST_F(ClientLibrary, accesses_display_info)
+TEST_F(ClientLibraryStubbedPlatform, accesses_display_info)
 {
     mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
 
 
=== modified file 'tests/include/mir_test_doubles/mock_display.h'
--- tests/include/mir_test_doubles/mock_display.h	2014-10-01 06:25:56 +0000
+++ tests/include/mir_test_doubles/mock_display.h	2014-11-18 19:29:59 +0000
@@ -48,6 +48,7 @@
     MOCK_METHOD0(resume, void());
     MOCK_METHOD1(create_hardware_cursor, std::shared_ptr<graphics::Cursor>(std::shared_ptr<graphics::CursorImage> const&));
     MOCK_METHOD0(create_gl_context, std::unique_ptr<graphics::GLContext>());
+    MOCK_METHOD0(vsync_provider, std::shared_ptr<frontend::VsyncProvider>());
 };
 
 }
 
=== modified file 'tests/include/mir_test_doubles/mock_hwc_vsync_coordinator.h'
--- tests/include/mir_test_doubles/mock_hwc_vsync_coordinator.h	2014-03-06 06:05:17 +0000
+++ tests/include/mir_test_doubles/mock_hwc_vsync_coordinator.h	2014-11-18 19:29:59 +0000
@@ -34,7 +34,9 @@
 {
     ~MockVsyncCoordinator() noexcept {}
     MOCK_METHOD0(wait_for_vsync, void());
-    MOCK_METHOD0(notify_vsync, void());
+    MOCK_METHOD1(notify_vsync, void(std::chrono::nanoseconds));
+    
+    MOCK_METHOD1(last_vsync_for, std::chrono::nanoseconds(graphics::DisplayConfigurationOutputId));
 };
 
 
 
=== modified file 'tests/include/mir_test_doubles/null_display.h'
--- tests/include/mir_test_doubles/null_display.h	2014-11-03 06:51:26 +0000
+++ tests/include/mir_test_doubles/null_display.h	2014-11-18 19:29:59 +0000
@@ -66,6 +66,11 @@
     {
         return std::unique_ptr<NullGLContext>{new NullGLContext()};
     }
+    
+    std::shared_ptr<frontend::VsyncProvider> vsync_provider()
+    {
+        return nullptr;
+    }
 };
 
 }
 
=== modified file 'tests/include/mir_test_doubles/stub_display.h'
--- tests/include/mir_test_doubles/stub_display.h	2014-06-17 11:21:31 +0000
+++ tests/include/mir_test_doubles/stub_display.h	2014-11-18 19:29:59 +0000
@@ -22,6 +22,7 @@
 #include "null_display.h"
 #include "stub_display_buffer.h"
 #include "stub_display_configuration.h"
+#include "stub_vsync_provider.h"
 
 #include "mir/geometry/rectangle.h"
 
@@ -56,6 +57,11 @@
             new StubDisplayConfig(output_rects)
         );
     }
+    
+    std::shared_ptr<frontend::VsyncProvider> vsync_provider() override
+    {
+        return std::make_shared<StubVsyncProvider>();
+    }
 
 private:
     std::vector<geometry::Rectangle> const output_rects;
 
=== modified file 'tests/include/mir_test_doubles/stub_display_builder.h'
--- tests/include/mir_test_doubles/stub_display_builder.h	2014-10-01 06:25:56 +0000
+++ tests/include/mir_test_doubles/stub_display_builder.h	2014-11-18 19:29:59 +0000
@@ -84,6 +84,11 @@
                 new StubConfigurableDisplayBuffer(geometry::Rectangle{{0,0},sz}));
     }
     
+    std::shared_ptr<graphics::android::HWCVsyncCoordinator> vsync_coordinator() const
+    {
+        return nullptr;
+    }
+
     geometry::Size sz;
 };
 }
 
=== modified file 'tests/include/mir_test_doubles/stub_host_connection.h'
--- tests/include/mir_test_doubles/stub_host_connection.h	2014-04-23 14:19:34 +0000
+++ tests/include/mir_test_doubles/stub_host_connection.h	2014-11-18 19:29:59 +0000
@@ -55,6 +55,7 @@
         public:
             EGLNativeWindowType egl_native_window() override { return {}; }
             void set_event_handler(MirEventDelegate const*) override {}
+            std::chrono::nanoseconds last_display_time() override { return std::chrono::nanoseconds::min(); }
         };
 
         return std::make_shared<NullHostSurface>();
 
=== added file 'tests/include/mir_test_doubles/stub_vsync_provider.h'
--- tests/include/mir_test_doubles/stub_vsync_provider.h	1970-01-01 00:00:00 +0000
+++ tests/include/mir_test_doubles/stub_vsync_provider.h	2014-11-18 19:29:59 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_VSYNC_PROVIDER_H_
+#define MIR_TEST_DOUBLES_STUB_VSYNC_PROVIDER_H_
+
+#include "mir/frontend/vsync_provider.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubVsyncProvider : public frontend::VsyncProvider
+{
+    std::chrono::nanoseconds last_vsync_for(graphics::DisplayConfigurationOutputId) override 
+    {
+        return std::chrono::nanoseconds::zero();
+    }
+};
+
+}
+}
+}
+
+#endif // MIR_TEST_DOUBLES_STUB_VSYNC_PROVIDER_H_
 
=== modified file 'tests/include/mir_test_framework/using_stub_client_platform.h'
--- tests/include/mir_test_framework/using_stub_client_platform.h	2014-11-11 15:50:11 +0000
+++ tests/include/mir_test_framework/using_stub_client_platform.h	2014-11-18 19:29:59 +0000
@@ -19,6 +19,8 @@
 #ifndef MIR_TEST_FRAMEWORK_USING_STUB_CLIENT_PLATFORM_H_
 #define MIR_TEST_FRAMEWORK_USING_STUB_CLIENT_PLATFORM_H_
 
+#include "src/client/connection_configuration.h"
+
 #include <memory>
 #include <functional>
 
 
=== modified file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	2014-11-18 03:21:20 +0000
+++ tests/integration-tests/CMakeLists.txt	2014-11-18 19:29:59 +0000
@@ -33,6 +33,7 @@
   test_server_shutdown.cpp
   test_session_manager.cpp
   test_session.cpp
+  test_vsync_to_client.cpp
   session_management.cpp
   surface_composition.cpp
   ${GENERATED_PROTOBUF_SRCS}
 
=== modified file 'tests/integration-tests/graphics/android/test_display_integration.cpp'
--- tests/integration-tests/graphics/android/test_display_integration.cpp	2014-10-21 16:21:14 +0000
+++ tests/integration-tests/graphics/android/test_display_integration.cpp	2014-11-18 19:29:59 +0000
@@ -22,6 +22,7 @@
 #include "src/platform/graphics/android/resource_factory.h"
 #include "src/platform/graphics/android/android_graphic_buffer_allocator.h"
 #include "src/platform/graphics/android/output_builder.h"
+#include "src/platform/graphics/android/hwc_vsync.h"
 #include "src/server/graphics/program_factory.h"
 #include "src/server/report/null_report_factory.h"
 
 
=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
--- tests/integration-tests/test_surfaceloop.cpp	2014-10-21 16:21:14 +0000
+++ tests/integration-tests/test_surfaceloop.cpp	2014-11-18 19:29:59 +0000
@@ -23,6 +23,7 @@
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/stub_display_buffer.h"
+#include "mir_test_doubles/stub_vsync_provider.h"
 
 #include "mir_test_framework/stubbed_server_configuration.h"
 #include "mir_test_framework/basic_client_server_fixture.h"
@@ -85,6 +86,12 @@
         f(display_buffer);
     }
 
+    std::shared_ptr<mf::VsyncProvider> vsync_provider() override
+    {
+        return std::make_shared<mtd::StubVsyncProvider>();
+    }
+
+
 private:
     mtd::StubDisplayBuffer display_buffer;
 };
 
=== added file 'tests/integration-tests/test_vsync_to_client.cpp'
--- tests/integration-tests/test_vsync_to_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/test_vsync_to_client.cpp	2014-11-18 19:29:59 +0000
@@ -0,0 +1,225 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "mir/frontend/vsync_provider.h"
+#include "mir/graphics/display_configuration.h"
+#include "mir/input/input_platform.h"
+#include "mir/input/input_receiver_thread.h"
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include "mir_test/fake_shared.h"
+#include "mir_test_framework/in_process_server.h"
+#include "mir_test_framework/stubbed_server_configuration.h"
+#include "mir_test_framework/stub_client_connection_configuration.h"
+#include "mir_test_framework/using_stub_client_platform.h"
+
+namespace mg = mir::graphics;
+namespace mi = mir::input;
+namespace mf = mir::frontend;
+namespace mircv = mi::receiver;
+namespace mt = mir::test;
+namespace mtf = mir_test_framework;
+
+namespace
+{
+// Client mocks and configuration
+struct MockInputReceiverThread : public mircv::InputReceiverThread
+{
+    MOCK_METHOD1(notify_of_frame_time, void(std::chrono::nanoseconds));
+    // Stub of uninteresting methods
+    void start() override {}
+    void stop() override {}
+    void join() override {}
+};
+
+struct MockInputThreadInputPlatform : public mircv::InputPlatform
+{
+    MockInputThreadInputPlatform(std::shared_ptr<mircv::InputReceiverThread> const& receiver_thread)
+        : mock_receiver_thread(receiver_thread)
+    {
+    }
+    std::shared_ptr<mircv::InputReceiverThread> create_input_thread(int, 
+        std::function<void(MirEvent *)> const&) override
+    {
+        return mock_receiver_thread;
+    }
+
+    std::shared_ptr<mircv::InputReceiverThread> const mock_receiver_thread;
+};
+
+struct InputMockInjectingClientConnectionConfiguration : public mtf::StubConnectionConfiguration
+{
+    InputMockInjectingClientConnectionConfiguration(std::string const& socket_file, std::shared_ptr<mircv::InputReceiverThread> const& receiver_thread)
+        : StubConnectionConfiguration(socket_file),
+          mock_input_platform(std::make_shared<MockInputThreadInputPlatform>(receiver_thread))
+    {
+    }
+    
+    std::shared_ptr<mircv::InputPlatform> the_input_platform() override
+    {
+        return input_platform(
+        [this]
+        {
+            return mock_input_platform;
+        });
+    }
+    std::shared_ptr<MockInputThreadInputPlatform> const mock_input_platform;
+};
+
+// Server mocks and configuration
+struct StubVsyncProvider : public mf::VsyncProvider
+{
+    StubVsyncProvider()
+        : count(0)
+    {
+    }
+
+    std::chrono::nanoseconds last_vsync_for(mg::DisplayConfigurationOutputId) override
+    {
+        return std::chrono::nanoseconds(count++);
+    }
+    int count;
+};
+
+struct StubVsyncProviderServerConfiguration : mtf::StubbedServerConfiguration
+{
+    std::shared_ptr<mf::VsyncProvider>
+    the_vsync_provider() override
+    {
+        return vsync_provider([]()
+        {
+            return std::make_shared<StubVsyncProvider>();
+        });
+    }
+    
+    std::shared_ptr<mi::InputManager> the_input_manager()
+    {
+        return DefaultServerConfiguration::the_input_manager();
+    }
+    std::shared_ptr<mi::InputSender> the_input_sender()
+    {
+        return DefaultServerConfiguration::the_input_sender();
+    }
+    std::shared_ptr<mi::InputDispatcher> the_input_dispatcher()
+    {
+        return DefaultServerConfiguration::the_input_dispatcher();
+    }
+};
+
+
+struct VsyncProviderTest : mtf::InProcessServer
+{
+    StubVsyncProviderServerConfiguration server_configuration;
+
+    mir::DefaultServerConfiguration& server_config() override { return server_configuration; }
+};
+
+}
+
+TEST_F(VsyncProviderTest, last_display_time)
+{
+    using namespace ::testing;
+
+    mtf::UsingStubClientPlatform using_stub_client_platform;
+
+    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+    MirSurfaceParameters const request_params =
+    {
+        __PRETTY_FUNCTION__,
+        640, 480,
+        mir_pixel_format_abgr_8888,
+        mir_buffer_usage_hardware,
+        mir_display_output_id_invalid
+    };
+    auto surface = mir_connection_create_surface_sync(connection, &request_params);
+    EXPECT_EQ(true, mir_surface_is_valid(surface));
+
+    // The fake vsync provider on server just increments an integer
+    // for each vsync request.
+    mir_surface_swap_buffers_sync(surface);
+    EXPECT_EQ(1, mir_surface_get_last_display_time(surface));
+    mir_surface_swap_buffers_sync(surface);
+    EXPECT_EQ(2, mir_surface_get_last_display_time(surface));
+    mir_surface_swap_buffers_sync(surface);
+    EXPECT_EQ(3, mir_surface_get_last_display_time(surface));
+    
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+namespace
+{
+void ignore_event(MirSurface*, MirEvent const*, void*)
+{
+}
+struct StubConfiguration : public InputMockInjectingClientConnectionConfiguration
+{
+    StubConfiguration(std::string const& socket_file)
+        : InputMockInjectingClientConnectionConfiguration(socket_file, mock_input_receiver_thread)
+    {
+    }
+    ~StubConfiguration()
+    {
+        mock_input_receiver_thread.reset();
+    }
+
+    static std::shared_ptr<MockInputReceiverThread> mock_input_receiver_thread;
+};
+
+std::shared_ptr<MockInputReceiverThread> StubConfiguration::mock_input_receiver_thread;
+}
+
+TEST_F(VsyncProviderTest, client_input_thread_receives_information_from_server_vsync_provider_on_buffer_swap)
+{
+    using namespace ::testing;
+    
+    StubConfiguration::mock_input_receiver_thread = std::make_shared<MockInputReceiverThread>();
+    
+    mtf::UsingClientPlatform<StubConfiguration> using_stub_client_platform;
+    MirEventDelegate delegate{ignore_event, NULL};
+
+    {
+        InSequence seq;
+        // The fake vsync provider just uses increments for each vsync request.
+        EXPECT_CALL(*StubConfiguration::mock_input_receiver_thread, notify_of_frame_time(std::chrono::nanoseconds(1)));
+        EXPECT_CALL(*StubConfiguration::mock_input_receiver_thread, notify_of_frame_time(std::chrono::nanoseconds(2)));
+        EXPECT_CALL(*StubConfiguration::mock_input_receiver_thread, notify_of_frame_time(std::chrono::nanoseconds(3)));
+    }
+
+    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+    MirSurfaceParameters const request_params =
+    {
+        __PRETTY_FUNCTION__,
+        640, 480,
+        mir_pixel_format_abgr_8888,
+        mir_buffer_usage_hardware,
+        mir_display_output_id_invalid
+    };
+    auto surface = mir_connection_create_surface_sync(connection, &request_params);
+
+    // Without a handler the client input thread will not be started.
+    mir_surface_set_event_handler(surface, &delegate);
+
+    mir_surface_swap_buffers_sync(surface);
+    mir_surface_swap_buffers_sync(surface);
+    mir_surface_swap_buffers_sync(surface);
+    
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
 
=== modified file 'tests/mir_test_framework/stubbed_graphics_platform.cpp'
--- tests/mir_test_framework/stubbed_graphics_platform.cpp	2014-11-13 16:41:26 +0000
+++ tests/mir_test_framework/stubbed_graphics_platform.cpp	2014-11-18 19:29:59 +0000
@@ -23,6 +23,7 @@
 
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/stub_display.h"
+#include "mir_test_doubles/stub_vsync_provider.h"
 
 #ifdef ANDROID
 #include "mir_test_doubles/stub_android_native_buffer.h"
@@ -37,6 +38,7 @@
 #include <boost/throw_exception.hpp>
 
 namespace geom = mir::geometry;
+namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace mo = mir::options;
 namespace mtd = mir::test::doubles;
 
=== modified file 'tests/unit-tests/client/input/test_android_input_receiver.cpp'
--- tests/unit-tests/client/input/test_android_input_receiver.cpp	2014-10-21 16:21:14 +0000
+++ tests/unit-tests/client/input/test_android_input_receiver.cpp	2014-11-18 19:29:59 +0000
@@ -204,102 +204,6 @@
     EXPECT_FALSE(receiver.next_event(std::chrono::milliseconds(1), ev)); // Minimal timeout needed for valgrind
 }
 
-TEST_F(AndroidInputReceiverSetup, slow_raw_input_doesnt_cause_frameskipping)
-{   // Regression test for LP: #1372300
-    using namespace testing;
-    using namespace std::chrono;
-
-    nsecs_t t = 0;
-
-    mircva::InputReceiver receiver(
-        client_fd, std::make_shared<mircv::NullInputReceiverReport>(),
-        [&t](int) { return t; }
-        );
-    TestingInputProducer producer(server_fd);
-
-    nsecs_t const one_millisecond = 1000000ULL;
-    nsecs_t const one_second = 1000 * one_millisecond;
-    nsecs_t const one_frame = one_second / 60;
-
-    MirEvent ev;
-
-    producer.produce_a_motion_event(123, 456, t);
-    producer.produce_a_key_event();
-    flush_channels();
-
-    std::chrono::milliseconds const max_timeout(1000);
-
-    // Key events don't get resampled. Will be reported first.
-    ASSERT_TRUE(receiver.next_event(max_timeout, ev));
-    ASSERT_EQ(mir_event_type_key, ev.type);
-
-    // The motion is still too new. Won't be reported yet, but is batched.
-    auto start = high_resolution_clock::now();
-    ASSERT_FALSE(receiver.next_event(max_timeout, ev));
-    auto end = high_resolution_clock::now();
-    auto duration = end - start;
-
-    // Verify we timed out in under a frame (LP: #1372300)
-    // Sadly using real time as droidinput::Looper doesn't use a mocked clock.
-    ASSERT_LT(duration_cast<nanoseconds>(duration).count(), one_frame);
-
-    // Verify we don't use all the CPU by not sleeping (LP: #1373809)
-    EXPECT_GT(duration_cast<nanoseconds>(duration).count(), one_millisecond);
-
-    // But later in a frame or so, the motion will be reported:
-    t += 2 * one_frame;  // Account for the new slower 55Hz event rate
-    ASSERT_TRUE(receiver.next_event(max_timeout, ev));
-    ASSERT_EQ(mir_event_type_motion, ev.type);
-}
-
-TEST_F(AndroidInputReceiverSetup, rendering_does_not_lag_behind_input)
-{
-    using namespace testing;
-
-    nsecs_t t = 0;
-
-    mircva::InputReceiver receiver(
-        client_fd, std::make_shared<mircv::NullInputReceiverReport>(),
-        [&t](int) { return t; }
-        );
-    TestingInputProducer producer(server_fd);
-
-    nsecs_t const one_millisecond = 1000000ULL;
-    nsecs_t const one_second = 1000 * one_millisecond;
-    nsecs_t const device_sample_interval = one_second / 250;
-    nsecs_t const frame_interval = one_second / 60;
-    nsecs_t const gesture_duration = 1 * one_second;
-
-    nsecs_t last_produced = 0;
-    int frames_triggered = 0;
-
-    for (t = 0; t < gesture_duration; t += one_millisecond)
-    {
-        if (!t || t >= (last_produced + device_sample_interval))
-        {
-            last_produced = t;
-            float a = t * M_PI / 1000000.0f;
-            float x = 500.0f * sinf(a);
-            float y = 1000.0f * cosf(a);
-            producer.produce_a_motion_event(x, y, t);
-            flush_channels();
-        }
-
-        MirEvent ev;
-        if (receiver.next_event(std::chrono::milliseconds(0), ev))
-            ++frames_triggered;
-    }
-
-    // If the rendering time resulting from the gesture is longer than the
-    // gesture itself then that's laggy...
-    nsecs_t render_duration = frame_interval * frames_triggered;
-    EXPECT_THAT(render_duration, Le(gesture_duration));
-
-    int average_lag_milliseconds = (render_duration - gesture_duration) /
-                                   (frames_triggered * one_millisecond);
-    EXPECT_THAT(average_lag_milliseconds, Le(1));
-}
-
 TEST_F(AndroidInputReceiverSetup, input_comes_in_phase_with_rendering)
 {
     using namespace testing;
 
=== modified file 'tests/unit-tests/client/test_client_mir_surface.cpp'
--- tests/unit-tests/client/test_client_mir_surface.cpp	2014-10-28 13:59:51 +0000
+++ tests/unit-tests/client/test_client_mir_surface.cpp	2014-11-18 19:29:59 +0000
@@ -289,6 +289,7 @@
     MOCK_METHOD0(start, void());
     MOCK_METHOD0(stop, void());
     MOCK_METHOD0(join, void());
+    MOCK_METHOD1(notify_of_frame_time, void(std::chrono::nanoseconds));
 };
 
 class TestConnectionConfiguration : public mcl::DefaultConnectionConfiguration
 
=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2014-11-13 16:41:26 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2014-11-18 19:29:59 +0000
@@ -42,6 +42,7 @@
 #include "mir_test_doubles/mock_buffer.h"
 #include "mir_test_doubles/stub_session.h"
 #include "mir_test_doubles/stub_display_configuration.h"
+#include "mir_test_doubles/stub_vsync_provider.h"
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/null_screencast.h"
 #include "mir_test/display_config_matchers.h"
@@ -205,6 +206,39 @@
     MOCK_METHOD0(supported_pixel_formats, std::vector<MirPixelFormat>());
 };
 
+
+class MockPlatform : public mg::Platform
+{
+ public:
+    MockPlatform(std::shared_ptr<mg::PlatformIpcOperations> const& ipc_ops)
+    {
+        using namespace testing;
+        ON_CALL(*this, create_buffer_allocator())
+            .WillByDefault(Return(std::shared_ptr<mg::GraphicBufferAllocator>()));
+        ON_CALL(*this, create_display(_,_,_))
+            .WillByDefault(Return(std::make_shared<mtd::NullDisplay>()));
+        ON_CALL(*this, make_vsync_provider())
+            .WillByDefault(Return(std::make_shared<mtd::StubVsyncProvider>()));
+        ON_CALL(*this, connection_ipc_package())
+            .WillByDefault(Return(std::make_shared<mg::PlatformIPCPackage>()));
+        ON_CALL(*this, make_ipc_operations())
+            .WillByDefault(Return(ipc_ops));
+    }
+
+    MOCK_METHOD0(create_buffer_allocator, std::shared_ptr<mg::GraphicBufferAllocator>());
+    MOCK_METHOD3(create_display,
+                 std::shared_ptr<mg::Display>(
+                     std::shared_ptr<mg::DisplayConfigurationPolicy> const&,
+                     std::shared_ptr<mg::GLProgramFactory> const&,
+                     std::shared_ptr<mg::GLConfig> const&));
+    MOCK_METHOD0(connection_ipc_package, std::shared_ptr<mg::PlatformIPCPackage>());
+    MOCK_METHOD0(create_internal_client, std::shared_ptr<mg::InternalClient>());
+    MOCK_CONST_METHOD0(make_ipc_operations, std::shared_ptr<mg::PlatformIpcOperations>());
+    MOCK_CONST_METHOD0(egl_native_display, EGLNativeDisplayType());
+    MOCK_METHOD0(make_buffer_writer, std::shared_ptr<mg::BufferWriter>());
+    MOCK_METHOD0(make_vsync_provider, std::shared_ptr<mf::VsyncProvider>());
+};
+
 struct StubScreencast : mtd::NullScreencast
 {
     std::shared_ptr<mg::Buffer> capture(mf::ScreencastSessionId)
@@ -230,7 +264,7 @@
             shell, mt::fake_shared(mock_ipc_operations), graphics_changer,
             surface_pixel_formats, report,
             std::make_shared<mtd::NullEventSink>(),
-            resource_cache, stub_screencast, &connector, nullptr, nullptr}
+            resource_cache, stub_screencast, &connector, nullptr, std::make_shared<mtd::StubVsyncProvider>(), nullptr}
     {
         using namespace ::testing;
 
@@ -286,7 +320,9 @@
         shell, mt::fake_shared(mock_ipc_operations), graphics_changer,
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(),
-        resource_cache, stub_screencast, context, nullptr, nullptr};
+        resource_cache, stub_screencast, context, nullptr,
+        std::make_shared<mtd::StubVsyncProvider>(), nullptr
+    };
 
     EXPECT_THAT(connects_handled_count, Eq(0));
 
@@ -391,7 +427,10 @@
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(),
         resource_cache, std::make_shared<mtd::NullScreencast>(),
-        nullptr, nullptr, nullptr);
+        nullptr, nullptr,
+        std::make_shared<mtd::StubVsyncProvider>(), nullptr
+    );
+
     mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
     EXPECT_THAT(connection.display_configuration(), mt::DisplayConfigMatches(std::cref(config)));
@@ -593,7 +632,9 @@
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(), resource_cache,
         std::make_shared<mtd::NullScreencast>(),
-         nullptr, nullptr, nullptr};
+        nullptr, nullptr,
+        std::make_shared<mtd::StubVsyncProvider>(), nullptr
+    };
 
     mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
@@ -846,7 +887,9 @@
         shell, mt::fake_shared(mock_ipc_operations), graphics_changer,
         surface_pixel_formats, report,
         std::make_shared<mtd::NullEventSink>(),
-        mt::fake_shared(mock_cache), stub_screencast, &connector, nullptr, nullptr};
+        mt::fake_shared(mock_cache), stub_screencast, nullptr, nullptr,
+        std::make_shared<mtd::StubVsyncProvider>(), nullptr
+    };
 
     mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
     mediator.create_surface(nullptr, &surface_parameters, &surface_response, null_callback.get());
 
=== modified file 'tests/unit-tests/graphics/android/CMakeLists.txt'
--- tests/unit-tests/graphics/android/CMakeLists.txt	2014-10-29 18:44:15 +0000
+++ tests/unit-tests/graphics/android/CMakeLists.txt	2014-11-18 19:29:59 +0000
@@ -29,6 +29,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_device_detection.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_wrapper.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_fallback_gl_renderer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_vsync.cpp
   $<TARGET_OBJECTS:mirplatformgraphicsandroidobjects>
 )
 
 
=== modified file 'tests/unit-tests/graphics/android/test_hwc_common_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_common_device.cpp	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/android/test_hwc_common_device.cpp	2014-11-18 19:29:59 +0000
@@ -195,14 +195,16 @@
         .WillOnce(SaveArg<0>(&callbacks));
 
     auto device = make_hwc_device<TypeParam>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+    
+    int64_t const fake_vsync_timestamp = 17;
 
-    EXPECT_CALL(*this->mock_vsync, notify_vsync())
+    EXPECT_CALL(*this->mock_vsync, notify_vsync(std::chrono::nanoseconds(fake_vsync_timestamp)))
         .Times(1);
     ASSERT_THAT(callbacks, Ne(nullptr));
-    callbacks->hooks.vsync(&callbacks->hooks, 0, 0);
+    callbacks->hooks.vsync(&callbacks->hooks, 0, fake_vsync_timestamp);
 
     callbacks->self = nullptr;
-    callbacks->hooks.vsync(&callbacks->hooks, 0, 0);
+    callbacks->hooks.vsync(&callbacks->hooks, 0, fake_vsync_timestamp);
 }
 
 TYPED_TEST(HWCCommon, set_orientation)
 
=== added file 'tests/unit-tests/graphics/android/test_hwc_vsync.cpp'
--- tests/unit-tests/graphics/android/test_hwc_vsync.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_hwc_vsync.cpp	2014-11-18 19:29:59 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "src/platform/graphics/android/hwc_vsync.h"
+
+#include "mir/graphics/display_configuration.h"
+
+#include <stdexcept>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mg = mir::graphics;
+namespace mga = mg::android;
+
+namespace
+{
+struct HWCVsyncTest : public testing::Test
+{
+    mga::HWCVsync syncer;
+
+    mg::DisplayConfigurationOutputId const output_id{0};
+    mg::DisplayConfigurationOutputId const invalid_output_id{1};
+};
+}
+
+TEST_F(HWCVsyncTest, initially_last_vsync_is_zero)
+{
+    EXPECT_EQ(std::chrono::nanoseconds::zero(), syncer.last_vsync_for(output_id));
+}
+
+// No multimonitor support on android drivers yet so non zero output ID is invalid.
+TEST_F(HWCVsyncTest, throws_exception_on_non_zero_output_id)
+{
+    EXPECT_THROW({
+            syncer.last_vsync_for(invalid_output_id);
+    }, std::runtime_error);
+}
+
+TEST_F(HWCVsyncTest, takes_time_from_last_vsync_notification)
+{
+    std::chrono::nanoseconds first_time{1}, second_time{2};
+    
+    EXPECT_EQ(std::chrono::nanoseconds::zero(), syncer.last_vsync_for(output_id));
+
+    syncer.notify_vsync(first_time);
+    EXPECT_EQ(first_time, syncer.last_vsync_for(output_id));
+    EXPECT_EQ(first_time, syncer.last_vsync_for(output_id));
+
+    syncer.notify_vsync(second_time);
+    EXPECT_EQ(second_time, syncer.last_vsync_for(output_id));
+    EXPECT_EQ(second_time, syncer.last_vsync_for(output_id));
+}
 
=== modified file 'tests/unit-tests/graphics/android/test_output_builder.cpp'
--- tests/unit-tests/graphics/android/test_output_builder.cpp	2014-10-27 13:06:48 +0000
+++ tests/unit-tests/graphics/android/test_output_builder.cpp	2014-11-18 19:29:59 +0000
@@ -68,6 +68,7 @@
         ON_CALL(*this, create_fb_device(_)).WillByDefault(Return(nullptr));
         ON_CALL(*this, create_hwc_device(_)).WillByDefault(Return(nullptr));
         ON_CALL(*this, create_hwc_fb_device(_,_)).WillByDefault(Return(nullptr));
+        ON_CALL(*this, create_vsync_coordinator()).WillByDefault(Return(nullptr));
     }
 
     MOCK_CONST_METHOD0(create_hwc_native_device, std::shared_ptr<hwc_composer_device_1>());
@@ -83,6 +84,7 @@
     MOCK_CONST_METHOD2(create_hwc_fb_device,
         std::shared_ptr<mga::DisplayDevice>(
             std::shared_ptr<mga::HwcWrapper> const&, std::shared_ptr<framebuffer_device_t> const&));
+    MOCK_CONST_METHOD0(create_vsync_coordinator, std::shared_ptr<mga::HWCVsyncCoordinator>());
 };
 
 class OutputBuilder : public ::testing::Test
 
=== modified file 'tests/unit-tests/graphics/android/test_resource_factory.cpp'
--- tests/unit-tests/graphics/android/test_resource_factory.cpp	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/android/test_resource_factory.cpp	2014-11-18 19:29:59 +0000
@@ -19,13 +19,16 @@
 #include "src/platform/graphics/android/resource_factory.h"
 #include "mir_test_doubles/mock_android_hw.h"
 
+#include "mir_test/fake_shared.h"
+
 #include <stdexcept>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace mg=mir::graphics;
-namespace mga=mir::graphics::android;
-namespace mtd=mir::test::doubles;
+namespace mg = mir::graphics;
+namespace mga = mir::graphics::android;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 
 struct ResourceFactoryTest  : public ::testing::Test
 {
 
=== modified file 'tests/unit-tests/graphics/nested/test_nested_display.cpp'
--- tests/unit-tests/graphics/nested/test_nested_display.cpp	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/nested/test_nested_display.cpp	2014-11-18 19:29:59 +0000
@@ -18,6 +18,7 @@
 
 #include "src/server/graphics/nested/nested_display.h"
 #include "src/server/graphics/nested/host_connection.h"
+#include "src/server/graphics/nested/nested_vsync_provider.h"
 #include "src/server/report/null/display_report.h"
 #include "src/server/graphics/default_display_configuration_policy.h"
 #include "src/server/input/null_input_dispatcher.h"
 
=== modified file 'tests/unit-tests/graphics/nested/test_nested_display_buffer.cpp'
--- tests/unit-tests/graphics/nested/test_nested_display_buffer.cpp	2014-06-04 22:09:06 +0000
+++ tests/unit-tests/graphics/nested/test_nested_display_buffer.cpp	2014-11-18 19:29:59 +0000
@@ -19,6 +19,7 @@
 
 #include "src/server/graphics/nested/nested_output.h"
 #include "src/server/graphics/nested/host_connection.h"
+#include "src/server/graphics/nested/nested_vsync_provider.h"
 #include "src/server/input/null_input_dispatcher.h"
 
 #include "mir_test_doubles/mock_egl.h"
@@ -29,8 +30,9 @@
 #include <gmock/gmock.h>
 
 namespace geom = mir::geometry;
-namespace mgn = mir::graphics::nested;
-namespace mgnd = mir::graphics::nested::detail;
+namespace mg = mir::graphics;
+namespace mgn = mg::nested;
+namespace mgnd = mgn::detail;
 namespace mi = mir::input;
 namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
@@ -40,6 +42,7 @@
 public:
     EGLNativeWindowType egl_native_window() override { return {}; }
     void set_event_handler(MirEventDelegate const*) override {}
+    std::chrono::nanoseconds last_display_time() override { return std::chrono::nanoseconds::min(); }
 };
 
 struct NestedDisplayBufferTest : testing::Test
@@ -55,6 +58,8 @@
     mi::NullInputDispatcher null_input_dispatcher;
     mgnd::EGLDisplayHandle egl_disp_handle;
     geom::Rectangle const default_rect;
+    mgn::VsyncProvider vsync_provider;
+    mg::DisplayConfigurationOutputId id;
 };
 
 TEST_F(NestedDisplayBufferTest, alpha_enabled_pixel_format_enables_destination_alpha)
@@ -64,7 +69,9 @@
         mt::fake_shared(null_host_surface),
         default_rect,
         mt::fake_shared(null_input_dispatcher),
-        mir_pixel_format_abgr_8888};
+        mir_pixel_format_abgr_8888,
+        mt::fake_shared(vsync_provider),
+        id};
 
     EXPECT_TRUE(db.uses_alpha());
 }
@@ -76,7 +83,9 @@
         mt::fake_shared(null_host_surface),
         default_rect,
         mt::fake_shared(null_input_dispatcher),
-        mir_pixel_format_xbgr_8888};
+        mir_pixel_format_xbgr_8888,
+        mt::fake_shared(vsync_provider),
+        id};
 
     EXPECT_FALSE(db.uses_alpha());
 }