Mir

Merge lp:~alan-griffiths/mir/drag-and-drop-II into lp:mir

drag-and-drop-II
Merge into development-branch

Proposed by Alan Griffiths on 2017-03-14

Status:	Superseded
Proposed branch:	lp:~alan-griffiths/mir/drag-and-drop-II
Merge into:	lp:mir
Diff against target:	2548 lines (+1425/-27) 75 files modified examples/server_example_basic_window_manager.cpp (+8/-0) examples/server_example_basic_window_manager.h (+5/-0) include/client/mir/events/event_builders.h (+2/-0) include/client/mir_toolkit/extensions/drag_and_drop.h (+81/-0) include/server/mir/scene/null_surface_observer.h (+1/-0) include/server/mir/scene/surface.h (+1/-0) include/server/mir/scene/surface_observer.h (+2/-0) include/server/mir/shell/abstract_shell.h (+8/-0) include/server/mir/shell/focus_controller.h (+5/-0) include/server/mir/shell/input_targeter.h (+5/-0) include/server/mir/shell/shell.h (+4/-0) include/server/mir/shell/shell_wrapper.h (+8/-0) include/server/mir/shell/system_compositor_window_manager.h (+5/-0) include/server/mir/shell/window_manager.h (+5/-0) include/test/mir/test/doubles/mock_window_manager.h (+1/-0) include/test/mir/test/doubles/stub_surface.h (+1/-0) include/test/mir_test_framework/observant_shell.h (+8/-0) src/capnproto/mir_event.capnp (+5/-1) src/client/CMakeLists.txt (+2/-0) src/client/drag_and_drop.cpp (+85/-0) src/client/drag_and_drop.h (+32/-0) src/client/events/event_builders.cpp (+25/-0) src/client/mir_blob.cpp (+1/-8) src/client/mir_connection.cpp (+4/-0) src/client/mir_surface.cpp (+32/-0) src/client/mir_surface.h (+4/-0) src/client/rpc/mir_display_server.cpp (+9/-0) src/client/rpc/mir_display_server.h (+4/-0) src/client/symbols.map (+2/-0) src/common/events/pointer_event.cpp (+41/-3) src/common/events/surface_event.cpp (+39/-1) src/common/symbols.map (+4/-0) src/include/common/mir/events/pointer_event.h (+6/-1) src/include/common/mir/events/surface_event.h (+6/-1) src/include/common/mir/protobuf/display_server.h (+4/-0) src/include/common/mir_blob.h (+32/-0) src/include/server/mir/frontend/shell.h (+5/-0) src/include/server/mir/scene/surface_event_source.h (+1/-0) src/include/server/mir/scene/surface_observers.h (+1/-0) src/include/server/mir/shell/basic_window_manager.h (+15/-0) src/include/server/mir/shell/canonical_window_manager.h (+4/-0) src/protobuf/mir_protobuf.proto (+5/-0) src/protobuf/symbols.map (+26/-0) src/server/frontend/protobuf_message_processor.cpp (+4/-0) src/server/frontend/session_mediator.cpp (+20/-1) src/server/frontend/session_mediator.h (+4/-0) src/server/frontend/shell_wrapper.cpp (+8/-0) src/server/frontend/shell_wrapper.h (+5/-0) src/server/input/null_input_targeter.h (+3/-0) src/server/input/surface_input_dispatcher.cpp (+42/-8) src/server/input/surface_input_dispatcher.h (+5/-1) src/server/scene/basic_surface.cpp (+11/-0) src/server/scene/basic_surface.h (+1/-0) src/server/scene/legacy_surface_change_notification.cpp (+4/-0) src/server/scene/legacy_surface_change_notification.h (+1/-0) src/server/scene/null_surface_observer.cpp (+1/-0) src/server/scene/surface_event_source.cpp (+5/-0) src/server/shell/abstract_shell.cpp (+17/-0) src/server/shell/basic_window_manager.cpp (+21/-0) src/server/shell/canonical_window_manager.cpp (+13/-0) src/server/shell/frontend_shell.cpp (+10/-0) src/server/shell/frontend_shell.h (+5/-0) src/server/shell/shell_wrapper.cpp (+18/-0) src/server/shell/system_compositor_window_manager.cpp (+7/-0) src/server/symbols.map (+10/-0) tests/acceptance-tests/CMakeLists.txt (+2/-0) tests/acceptance-tests/drag_and_drop.cpp (+624/-0) tests/acceptance-tests/test_client_cursor_api.cpp (+1/-0) tests/include/mir/test/doubles/mock_input_targeter.h (+3/-0) tests/include/mir/test/doubles/mock_shell.h (+3/-0) tests/include/mir/test/doubles/stub_display_server.h (+4/-0) tests/include/mir/test/doubles/stub_input_targeter.h (+3/-0) tests/include/mir/test/doubles/stub_scene_surface.h (+1/-0) tests/mir_test_framework/observant_shell.cpp (+21/-2) tests/mir_test_framework/stub_surface.cpp (+4/-0)
To merge this branch:	bzr merge lp:~alan-griffiths/mir/drag-and-drop-II
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Alan Griffiths			Needs Information on 2017-03-16
Andreas Pokorny (community)			Needs Information on 2017-03-16
Chris Halse Rogers			Needs Information on 2017-03-15
Brandon Schaefer (community)			Approve on 2017-03-15
Cemil Azizoglu (community)			Needs Information on 2017-03-15
Mir CI Bot	continuous-integration	2017-03-14	Approve on 2017-03-15
Kevin DuBois (community)			Approve on 2017-03-14
Review via email: mp+319820@code.launchpad.net

This proposal supersedes a proposal from 2017-03-13.

This proposal has been superseded by a proposal from 2017-03-17.

Commit Message

Initial support for Drag and Drop: tests (and implementation for) starting drag and releasing on target surface

Description of the Change

Initial support for Drag and Drop: tests (and implementation for) starting drag and releasing on target surface

One more episode to follow for handling the cancellation from content hub.

Mir CI Bot (mir-ci-bot) wrote on 2017-03-13: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3142/rebuild

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2017-03-14: Posted in a previous version of this proposal

18:39:25 [ RUN ] DragAndDrop.when_drag_moves_from_window_leave_event_contains_cookie
...
18:39:25 /<<BUILDDIR>>/mir-0.26.0+zesty4293bzr4086/tests/acceptance-tests/drag_and_drop.cpp:256: Failure
18:39:25 Value of: have_cookie.wait_for(receive_event_timeout)
18:39:25 Expected: is equal to true
18:39:25 Actual: false (of type bool)
18:39:25 ==11713== Invalid read of size 8

The memory errors and FD leaks that follow result from following the resulting nullptr.

review: Needs Fixing

Alan Griffiths (alan-griffiths) wrote on 2017-03-14: Posted in a previous version of this proposal

> 18:39:25 [ RUN ]
> DragAndDrop.when_drag_moves_from_window_leave_event_contains_cookie
> ...
> 18:39:25 /<<BUILDDIR>>/mir-0.26.0+zesty4293bzr4086/tests/acceptance-
> tests/drag_and_drop.cpp:256: Failure
> 18:39:25 Value of: have_cookie.wait_for(receive_event_timeout)
> 18:39:25 Expected: is equal to true
> 18:39:25 Actual: false (of type bool)
> 18:39:25 ==11713== Invalid read of size 8
>
> The memory errors and FD leaks that follow result from following the resulting
> nullptr.

Hmm wrong paste buffer, but still I don't see how this can happen:

18:35:34 11: [ RUN ] DragAndDrop.when_drag_moves_from_window_leave_event_contains_cookie
...
18:37:06 11: /<<BUILDDIR>>/mir-0.26.0+zesty4293bzr4086/tests/acceptance-tests/drag_and_drop.cpp:256: Failure
18:37:06 11: Value of: have_cookie.wait_for(receive_event_timeout)
18:37:06 11: Expected: is equal to true
18:37:06 11: Actual: false (of type bool)
18:37:06 11: ==11713== Invalid read of size 8

Basically, the click isn't seen by the window. And on this branch the window has definitely received {mir_window_attrib_focus, true}

Mir CI Bot (mir-ci-bot) wrote on 2017-03-14: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3151/rebuild

review: Needs Fixing (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2017-03-14: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3153/rebuild

review: Approve (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2017-03-14: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3154/rebuild

review: Approve (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2017-03-14:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3155/rebuild

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2017-03-14:

Failure is unrelated (lp:1660889)

So that's 3 CI runs with the new tests passing. (And soak testing them locally.)

lp:~alan-griffiths/mir/drag-and-drop-II updated on 2017-03-14

4092. By Alan Griffiths on 2017-03-14: Correct test names

Mir CI Bot (mir-ci-bot) wrote on 2017-03-14:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3158/rebuild

review: Approve (continuous-integration)

Kevin DuBois (kdub) wrote on 2017-03-14:

l773 could use comment here as well (like the other comment noting how CapPnP has problems)
+ //std::copy(dnd_handle.begin(), dnd_handle.end(), back_inserter(blob->data_));

+// We miss the "mouseover" occasionally (with valgrind and heavy stress about 1/20).
1995 +// But it isn't essential for the test and we've probably waited long enough
1996 +// for the mouse-down needed by the test to reach the window.
1997 +// EXPECT_THAT(have_mouseover.wait_for(receive_event_timeout), Eq(true));
does that need a bug?

both those minor, lgtm overall

review: Approve

lp:~alan-griffiths/mir/drag-and-drop-II updated on 2017-03-15

4093. By Alan Griffiths on 2017-03-15: Better comment
4094. By Alan Griffiths on 2017-03-15: merge :parent

Alan Griffiths (alan-griffiths) wrote on 2017-03-15:

> l773 could use comment here as well (like the other comment noting how CapPnP
> has problems)
> + //std::copy(dnd_handle.begin(), dnd_handle.end(),
> back_inserter(blob->data_));

Fixed.

> +// We miss the "mouseover" occasionally (with valgrind and heavy stress about
> 1/20).
> 1995 +// But it isn't essential for the test and we've probably waited long
> enough
> 1996 +// for the mouse-down needed by the test to reach the window.
> 1997 +// EXPECT_THAT(have_mouseover.wait_for(receive_event_timeout),
> Eq(true));
> does that need a bug?

Possibly. It would appear there is a lack of consistency between the window management "model" that says the surface is ready and has focus (hence the mir_window_attrib_focus notification in paint_window) and the input "model" that does not (yet) route input to the surface. That's what you get by updating observers asynchronously - which, given the code we landed to support it, appears to have been a deliberate decision.

I doubt we'll see an issue in "real life".

Mir CI Bot (mir-ci-bot) wrote on 2017-03-15:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3168/rebuild

review: Approve (continuous-integration)

Cemil Azizoglu (cemil-azizoglu) wrote on 2017-03-15:

Why is this an extension? Because it requires an outside entity like a content hub?
---------------------------------

Is this needed?

130 + mir_surface_attrib_drag_and_drop_handle,
---------------------------------

review: Needs Information

Alan Griffiths (alan-griffiths) wrote on 2017-03-15:

> Why is this an extension? Because it requires an outside entity like a content
> hub?

So that we can evolve the API without breaking ABI

> Is this needed?
>
> 130 + mir_surface_attrib_drag_and_drop_handle,
> ---------------------------------

It doesn't have to be done this way, but the mir_surface_attribs and mir_window_attribs enum members have to be kept in step somehow. This seemed the clearest approach.

Kevin DuBois (kdub) wrote on 2017-03-15:

> > Why is this an extension? Because it requires an outside entity like a
> content
> > hub?
>
> So that we can evolve the API without breaking ABI
+1 to evolving client api this way, keeps 1.0 stable, and can be incorporated to main api once the work is done and there are no more warts.

Brandon Schaefer (brandontschaefer) wrote on 2017-03-15:

lgtm

review: Approve

Chris Halse Rogers (raof) wrote on 2017-03-15:

Needs info:
I'm not sure that overriding the events is appropriate - as I understand it, this will result in Mir sending pointer_enter/pointer_leave/pointer_motion events in cases where we currently don't?

It looks like this will cause clients to behave incorrectly unless their event handler checks each pointer event for a drag handle, and treats pointer events with drag handles as not pointer events?

For example: given a client B that doesn't check pointer events for drag handles, if you initiate a drag and then move the pointer over B's window, this will act like you're just moving the pointer normally over B's window, and B will highlight buttons, perform on-hover actions, and so on? And then if you release the drag over a button in B's window, B will respond as if you mouse-button-released on that button, possibly activating it?

Nit: The locking in
+void MirSurface::request_drag_and_drop(MirCookie const* cookie)
appears unnecessary? All of the things it accesses are stack variables (cookie) or written-once-at-initialisation (surface_id).

Is the locking for the appeasement of ThreadSanitizer?

review: Needs Information

Andreas Pokorny (andreas-pokorny) wrote on 2017-03-16:

> Needs info:
> I'm not sure that overriding the events is appropriate - as I understand it,
> this will result in Mir sending pointer_enter/pointer_leave/pointer_motion
> events in cases where we currently don't?

Yes leaving the boundaries of a window even when buttons are pressed will cause the source window to receive a pointer leave and potentially crossed windows to receive pointer_enter and motion events even though pointer buttons are still pressed.

>
> It looks like this will cause clients to behave incorrectly unless their event
> handler checks each pointer event for a drag handle, and treats pointer events
> with drag handles as not pointer events?

I doubt ui toolkits unaware of the drag handle will treat it as a click sequence, so there is wrong behavior but not really severe.

We cannot safely expand enums with extensions - so we either expand the MirPointerAction enum in an unsafe and problematic way (i.e. we have values like mir_pointer_actions) or we do not treat this as an extension or we accept the possible damage we do to current clients.

Andreas Pokorny (andreas-pokorny) wrote on 2017-03-16:

Now looking again - why do we need a surface attribute for drag and drop?

Are downstreams using values like: mir_window_attribs?

I think we should remove those.

Besides the enum changes and window attribute - lgtm

review: Needs Information

Alan Griffiths (alan-griffiths) wrote on 2017-03-16:

> > Needs info:
> > I'm not sure that overriding the events is appropriate - as I understand it,
> > this will result in Mir sending pointer_enter/pointer_leave/pointer_motion
> > events in cases where we currently don't?
>
> Yes leaving the boundaries of a window even when buttons are pressed will
> cause the source window to receive a pointer leave and potentially crossed
> windows to receive pointer_enter and motion events even though pointer buttons
> are still pressed.
>
> >
> > It looks like this will cause clients to behave incorrectly unless their
> event
> > handler checks each pointer event for a drag handle, and treats pointer
> events
> > with drag handles as not pointer events?
>
> I doubt ui toolkits unaware of the drag handle will treat it as a click
> sequence, so there is wrong behavior but not really severe.

The Nuremberg defence: https://goo.gl/AfG5v2 - shows the D&D handle carried by the mouse movement events. I don't know the domain well enough to be certain if the behaviour of drag-and-drop oblivious clients could be significantly affected, but it seems unlikely.

Alan Griffiths (alan-griffiths) wrote on 2017-03-16:

> Now looking again - why do we need a surface attribute for drag and drop?
>
> Are downstreams using values like: mir_window_attribs?
>
> I think we should remove those.
>
> Besides the enum changes and window attribute - lgtm

We needed some event to carry the drag handle. Extending the window event seemed the path of least resistance. But we've hard-coded the existence of an attribute value pair into the API.

I can think of two alternatives:

/1/ Use window events as the transport, but filter out those with a D&D handle (and pass the handle to an entirely separate callback registered through the extension API).

/2/ Introduce a new drag-and-drop event to the transport.

If we were to introduce a new drag-and-drop event to carry the initial handle then we could also use it for leave/enter/move/release - which would address some of the concerns about using pointer made above.

OTOH /1/ seems simpler.

*Seeking guidance* on /1/ or /2/

review: Needs Information

Andreas Pokorny (andreas-pokorny) wrote on 2017-03-16:

Which route will allow us to easily expand drag and drop to touch guestures?

Alan Griffiths (alan-griffiths) wrote on 2017-03-16:

> Which route will allow us to easily expand drag and drop to touch guestures?

I imagine the client-side processing needs to be different (i.e. different visual effects) so it might be easier to "piggy back" on the existing input events. But without a design for D&D touch I can't be sure.

/me wonders if Unity7 has prior art.

Chris Halse Rogers (raof) wrote on 2017-03-16:

I'd be reasonably happy with (1).

If people don't like throwing in an ad-hoc callback for each extension, an alternative would be to assign event types *in* the extension, like so:

struct DnDv1
{
    int (*dnd_event_type)();
    MirDndEvent const* (*dnd_event_from_event)(MirEvent const*);
    MirBlob* (*dnd_event_get_handle)(MirDndEvent const*);
    MirDndAction (*dnd_event_get_action)(MirDndEvent const*);
}

…
DnDv1* dnd = mir_drag_and_drop_v1(connection);
…
<in event handler>
if (mir_event_get_type(event) == dnd->dnd_event_type())
{
    MirDndEvent const* dnd_event = dnd->dnd_event_from_event(event);
    if (dnd->dnd_event_get_action(dnd_event) == mir_dnd_event_enter)
    {
        handle_drop_enter_with_handle(dnd->dnd_event_get_handle(dnd_event));
        …
    }
}

I prefer this to one-callback-per-extension, but not strongly enough to block. I don't *think* it'd be significantly more work to implement than (1), though.

Alan Griffiths (alan-griffiths) wrote on 2017-03-17:

> I'd be reasonably happy with (1).
>
> If people don't like throwing in an ad-hoc callback for each extension, an
> alternative would be to assign event types *in* the extension, like so:
...
> if (mir_event_get_type(event) == dnd->dnd_event_type())

Perhaps:

- if (mir_event_get_type(event) == dnd->dnd_event_type())
+ if (dnd && dnd->is_dnd_event(event))

Chris Halse Rogers (raof) wrote on 2017-03-17:

Also happy with that :)

lp:~alan-griffiths/mir/drag-and-drop-II updated on 2017-03-17

4095. By Alan Griffiths on 2017-03-17: merge lp:~alan-griffiths/mir/drag-and-drop-III
4096. By Alan Griffiths on 2017-03-17: merge :parent
4097. By Alan Griffiths on 2017-03-17: Rework avoid a fake WindowEvent attribute

Unmerged revisions

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Alan Griffiths

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'examples/server_example_basic_window_manager.cpp'
 --- examples/server_example_basic_window_manager.cpp	2017-01-18 02:29:37 +0000
 +++ examples/server_example_basic_window_manager.cpp	2017-03-17 15:49:43 +0000
@@ -136,6 +136,14 @@
          policy->handle_raise_surface(session, surface);
+ }
++void me::BasicWindowManager::handle_request_drag_and_drop(
++    std::shared_ptr<scene::Session> const& /*session*/,
++    std::shared_ptr<scene::Surface> const& /*surface*/,
++    uint64_t /*timestamp*/)
++{
++    // Not supported in example servers
++}
++
  int me::BasicWindowManager::set_surface_attribute(
      std::shared_ptr<scene::Session> const& /*session*/,
      std::shared_ptr<scene::Surface> const& surface,
 === modified file 'examples/server_example_basic_window_manager.h'
 --- examples/server_example_basic_window_manager.h	2017-01-18 02:29:37 +0000
 +++ examples/server_example_basic_window_manager.h	2017-03-17 15:49:43 +0000
@@ -174,6 +174,11 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) override;
++    void handle_request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) override;
++
      int set_surface_attribute(
          std::shared_ptr<scene::Session> const& /*session*/,
          std::shared_ptr<scene::Surface> const& surface,
 === modified file 'include/client/mir/events/event_builders.h'
 --- include/client/mir/events/event_builders.h	2017-02-15 13:36:35 +0000
 +++ include/client/mir/events/event_builders.h	2017-03-17 15:49:43 +0000
@@ -161,6 +161,8 @@
  void transform_positions(MirEvent& event, mir::geometry::Displacement const& movement);
  void set_window_id(MirEvent& event, int window_id);
++EventUPtr make_start_drag_and_drop_event(frontend::SurfaceId const& surface_id, std::vector<uint8_t> const& handle);
++void set_drag_and_drop_handle(MirEvent& event, std::vector<uint8_t> const& handle);
+ }
+ }
 === added file 'include/client/mir_toolkit/extensions/drag_and_drop.h'
 --- include/client/mir_toolkit/extensions/drag_and_drop.h	1970-01-01 00:00:00 +0000
 +++ include/client/mir_toolkit/extensions/drag_and_drop.h	2017-03-17 15:49:43 +0000
@@ -0,0 +1,81 @@
++/*
++ * Copyright © 2017 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: Alan Griffiths <alan@octopull.co.uk>
++ */
++
++#ifndef MIR_DRAG_AND_DROP_H
++#define MIR_DRAG_AND_DROP_H
++
++#include "mir_toolkit/mir_extension_core.h"
++#include "mir_toolkit/client_types.h"
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++typedef struct MirDragAndDropEvent MirDragAndDropEvent;
++
++typedef struct MirDragAndDropV1
++{
++    /**
++     * Request drag and drop. If the request succeeds a window event with a
++     * "start drag" handle will be received.
++     *
++     * \warning An invalid cookie will terminate the client connection.
++     *
++     * \param [in] window  The source window
++     * \param [in] cookie  A cookie instance obtained from an input event.
++     */
++    void (*request_drag_and_drop)(MirWindow* window, MirCookie const* cookie);
++
++    /**
++     * Set the drag and drop callback. This receives
++     *
++     * \param [in] window   The window
++     * \param [in] callback The callback function.
++     * \param [in] context  To be passed to callback
++     */
++    void (*set_start_drag_and_drop_callback)(MirWindow* window,
++               void (*callback)(MirWindow* window, MirDragAndDropEvent const* event, void* context),
++               void* context);
++
++    /**
++     * Retrieve any "drag & drop" handle associated with the event.
++     *
++     * \param [in] event The event
++     * \return           The associated drag handle or NULL
++     */
++    MirBlob* (*start_drag_and_drop)(MirDragAndDropEvent const* event);
++
++    /**
++     * Retrieve any "drag & drop" handle associated with the event.
++     *
++     * \param [in] event The event
++     * \return           The associated drag handle or NULL
++     */
++    MirBlob* (*pointer_drag_and_drop)(MirPointerEvent const* event);
++
++} MirDragAndDropV1;
++
++static inline MirDragAndDropV1 const* mir_drag_and_drop_v1(MirConnection* connection)
++{
++    return (MirDragAndDropV1 const*) mir_connection_request_extension(connection, "mir_drag_and_drop", 1);
++}
++
++#ifdef __cplusplus
++}
++#endif
++#endif //MIR_DRAG_AND_DROP_H
 \ No newline at end of file
 === modified file 'include/server/mir/scene/null_surface_observer.h'
 --- include/server/mir/scene/null_surface_observer.h	2017-02-15 13:36:35 +0000
 +++ include/server/mir/scene/null_surface_observer.h	2017-03-17 15:49:43 +0000
@@ -47,6 +47,7 @@
      void cursor_image_removed() override;
      void placed_relative(geometry::Rectangle const& placement) override;
      void input_consumed(MirEvent const* event) override;
++    void start_drag_and_drop(std::vector<uint8_t> const& handle) override;
  protected:
      NullSurfaceObserver(NullSurfaceObserver const&) = delete;
 === modified file 'include/server/mir/scene/surface.h'
 --- include/server/mir/scene/surface.h	2017-02-15 14:45:41 +0000
 +++ include/server/mir/scene/surface.h	2017-03-17 15:49:43 +0000
@@ -116,6 +116,7 @@
      virtual MirPointerConfinementState confine_pointer_state() const = 0;
      virtual void placed_relative(geometry::Rectangle const& placement) = 0;
++    virtual void start_drag_and_drop(std::vector<uint8_t> const& handle) = 0;
  };
+ }
+ }
 === modified file 'include/server/mir/scene/surface_observer.h'
 --- include/server/mir/scene/surface_observer.h	2017-02-15 13:36:35 +0000
 +++ include/server/mir/scene/surface_observer.h	2017-03-17 15:49:43 +0000
@@ -27,6 +27,7 @@
  #include <glm/glm.hpp>
  #include <string>
++#include <vector>
  namespace mir
+ {
@@ -62,6 +63,7 @@
      virtual void cursor_image_removed() = 0;
      virtual void placed_relative(geometry::Rectangle const& placement) = 0;
      virtual void input_consumed(MirEvent const* event) = 0;
++    virtual void start_drag_and_drop(std::vector<uint8_t> const& handle) = 0;
  protected:
      SurfaceObserver() = default;
 === modified file 'include/server/mir/shell/abstract_shell.h'
 --- include/server/mir/shell/abstract_shell.h	2017-01-18 02:29:37 +0000
 +++ include/server/mir/shell/abstract_shell.h	2017-03-17 15:49:43 +0000
@@ -82,6 +82,11 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) override;
++    void request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) override;
++
      std::shared_ptr<scene::PromptSession> start_prompt_session_for(
          std::shared_ptr<scene::Session> const& session,
          scene::PromptSessionCreationParameters const& params) override;
@@ -124,6 +129,9 @@
      void update_focused_surface_confined_region();
++    void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) override;
++    void clear_drag_and_drop_handle() override;
++
  protected:
      std::shared_ptr<InputTargeter> const input_targeter;
      std::shared_ptr<SurfaceStack> const surface_stack;
 === modified file 'include/server/mir/shell/focus_controller.h'
 --- include/server/mir/shell/focus_controller.h	2016-01-29 08:18:22 +0000
 +++ include/server/mir/shell/focus_controller.h	2017-03-17 15:49:43 +0000
@@ -19,8 +19,10 @@
  #ifndef MIR_SHELL_FOCUS_CONTROLLER_H_
  #define MIR_SHELL_FOCUS_CONTROLLER_H_
++#include <stddef.h>
  #include <memory>
  #include <set>
++#include <vector>
  namespace mir
+ {
@@ -54,6 +56,9 @@
      virtual void raise(SurfaceSet const& surfaces) = 0;
++    virtual void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) = 0;
++    virtual void clear_drag_and_drop_handle() = 0;
++
  protected:
      FocusController() = default;
      FocusController(FocusController const&) = delete;
 === modified file 'include/server/mir/shell/input_targeter.h'
 --- include/server/mir/shell/input_targeter.h	2015-06-18 02:46:16 +0000
 +++ include/server/mir/shell/input_targeter.h	2017-03-17 15:49:43 +0000
@@ -19,7 +19,9 @@
  #ifndef MIR_SHELL_INPUT_TARGETER_H_
  #define MIR_SHELL_INPUT_TARGETER_H_
++#include <stddef.h>
  #include <memory>
++#include <vector>
  namespace mir
+ {
@@ -40,6 +42,9 @@
      virtual void set_focus(std::shared_ptr<input::Surface> const& focus_surface) = 0;
      virtual void clear_focus() = 0;
++    virtual void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) = 0;
++    virtual void clear_drag_and_drop_handle() = 0;
++
  protected:
      InputTargeter() = default;
      InputTargeter(InputTargeter const&) = delete;
 === modified file 'include/server/mir/shell/shell.h'
 --- include/server/mir/shell/shell.h	2017-01-19 00:27:55 +0000
 +++ include/server/mir/shell/shell.h	2017-03-17 15:49:43 +0000
@@ -100,6 +100,10 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) = 0;
++    virtual void request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) = 0;
  /** @} */
  };
+ }
 === modified file 'include/server/mir/shell/shell_wrapper.h'
 --- include/server/mir/shell/shell_wrapper.h	2017-01-18 02:29:37 +0000
 +++ include/server/mir/shell/shell_wrapper.h	2017-03-17 15:49:43 +0000
@@ -85,11 +85,19 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) override;
++    void request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) override;
++
      void add_display(geometry::Rectangle const& area) override;
      void remove_display(geometry::Rectangle const& area) override;
      bool handle(MirEvent const& event) override;
++    void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) override;
++    void clear_drag_and_drop_handle() override;
++
  protected:
      std::shared_ptr<Shell> const wrapped;
  };
 === modified file 'include/server/mir/shell/system_compositor_window_manager.h'
 --- include/server/mir/shell/system_compositor_window_manager.h	2017-01-18 02:29:37 +0000
 +++ include/server/mir/shell/system_compositor_window_manager.h	2017-03-17 15:49:43 +0000
@@ -95,6 +95,11 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) override;
++    void handle_request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) override;
++
      int set_surface_attribute(
          std::shared_ptr<scene::Session> const& session,
          std::shared_ptr<scene::Surface> const& surface,
 === modified file 'include/server/mir/shell/window_manager.h'
 --- include/server/mir/shell/window_manager.h	2017-01-18 02:29:37 +0000
 +++ include/server/mir/shell/window_manager.h	2017-03-17 15:49:43 +0000
@@ -76,6 +76,11 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) = 0;
++    virtual void handle_request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) = 0;
++
      virtual ~WindowManager() = default;
      WindowManager() = default;
      WindowManager(WindowManager const&) = delete;
 === modified file 'include/test/mir/test/doubles/mock_window_manager.h'
 --- include/test/mir/test/doubles/mock_window_manager.h	2017-01-18 02:29:37 +0000
 +++ include/test/mir/test/doubles/mock_window_manager.h	2017-03-17 15:49:43 +0000
@@ -58,6 +58,7 @@
      MOCK_METHOD1(handle_pointer_event, bool(MirPointerEvent const*));
      MOCK_METHOD3(handle_raise_surface, void(std::shared_ptr<scene::Session> const&, std::shared_ptr<scene::Surface> const&, uint64_t));
++    MOCK_METHOD3(handle_request_drag_and_drop, void(std::shared_ptr<scene::Session> const&, std::shared_ptr<scene::Surface> const&, uint64_t));
      MOCK_METHOD4(set_surface_attribute,
          int(std::shared_ptr<scene::Session> const& session,
 === modified file 'include/test/mir/test/doubles/stub_surface.h'
 --- include/test/mir/test/doubles/stub_surface.h	2017-02-15 14:45:41 +0000
 +++ include/test/mir/test/doubles/stub_surface.h	2017-03-17 15:49:43 +0000
@@ -70,6 +70,7 @@
      void set_confine_pointer_state(MirPointerConfinementState state) override;
      MirPointerConfinementState confine_pointer_state() const override;
      void placed_relative(geometry::Rectangle const& placement) override;
++    void start_drag_and_drop(std::vector<uint8_t> const& handle) override;
  };
+ }
+ }
 === modified file 'include/test/mir_test_framework/observant_shell.h'
 --- include/test/mir_test_framework/observant_shell.h	2017-01-20 00:01:50 +0000
 +++ include/test/mir_test_framework/observant_shell.h	2017-03-17 15:49:43 +0000
@@ -96,6 +96,14 @@
          std::shared_ptr<mir::scene::Surface> const& window,
          uint64_t timestamp) override;
++    void request_drag_and_drop(
++        std::shared_ptr<mir::scene::Session> const& session,
++        std::shared_ptr<mir::scene::Surface> const& window,
++        uint64_t timestamp) override;
++
++    void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) override;
++    void clear_drag_and_drop_handle() override;
++
  private:
      std::shared_ptr<mir::shell::Shell> const wrapped;
      std::shared_ptr<mir::scene::SurfaceObserver> const surface_observer;
 === modified file 'src/capnproto/mir_event.capnp'
 --- src/capnproto/mir_event.capnp	2017-02-17 08:46:05 +0000
 +++ src/capnproto/mir_event.capnp	2017-03-17 15:49:43 +0000
@@ -104,6 +104,8 @@
      buttons @7 :UInt32;
++    dndHandle @8 :List(UInt8);
++
      enum PointerAction
+     {
         up @0;
@@ -149,6 +151,7 @@
      id @0 :Int32;
      attrib @1 :Attrib;
      value @2 :Int32;
++    dndHandle @3 :List(UInt8);
      enum Attrib
+     {
@@ -160,8 +163,9 @@
          dpi @4;
          visibility @5;
          preferredOrientation @6;
++        startDragAndDrop @7;
          # Must be last
--        surfaceAttrib @7;
++        surfaceAttrib @8;
+     }
+ }
 === modified file 'src/client/CMakeLists.txt'
 --- src/client/CMakeLists.txt	2017-01-24 13:43:12 +0000
 +++ src/client/CMakeLists.txt	2017-03-17 15:49:43 +0000
@@ -49,6 +49,7 @@
  add_library(mirclientobjects OBJECT
    display_configuration.cpp
++  drag_and_drop.cpp drag_and_drop.h
    error_connections.cpp
    event.cpp
    event_printer.cpp
@@ -105,6 +106,7 @@
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_error.h
    mir_extension_core.cpp
    ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_extension_core.h
++  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/extensions/drag_and_drop.h
+ )
  # Ensure protobuf C++ headers have been produced before
 === added file 'src/client/drag_and_drop.cpp'
 --- src/client/drag_and_drop.cpp	1970-01-01 00:00:00 +0000
 +++ src/client/drag_and_drop.cpp	2017-03-17 15:49:43 +0000
@@ -0,0 +1,85 @@
++/*
++ * Copyright © 2017 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: Alan Griffiths <alan@octopull.co.uk>
++ */
++
++#include "drag_and_drop.h"
++#include "mir_toolkit/extensions/drag_and_drop.h"
++
++#include "mir/uncaught.h"
++#include "mir/events/surface_event.h"
++#include "mir/events/pointer_event.h"
++
++#include "mir_surface.h"
++
++namespace
++{
++
++void request_drag_and_drop(MirWindow* window, MirCookie const* cookie)
++try
++{
++    window->request_drag_and_drop(cookie);
++}
++catch (std::exception const& e)
++{
++    MIR_LOG_UNCAUGHT_EXCEPTION(e);
++    abort();
++}
++
++void set_start_drag_and_drop_callback(MirWindow* window,
++    void (*callback)(MirWindow* window, MirDragAndDropEvent const* event, void* context),
++    void* context)
++try
++{
++    window->set_drag_and_drop_start_handler([callback,window,context](MirWindowEvent const* event)
++        { callback(window, reinterpret_cast<MirDragAndDropEvent const*>(event), context); });
++}
++catch (std::exception const& e)
++{
++    MIR_LOG_UNCAUGHT_EXCEPTION(e);
++    abort();
++}
++
++MirBlob* start_drag_and_drop(MirDragAndDropEvent const* event)
++try
++{
++    return reinterpret_cast<MirWindowEvent const*>(event)->dnd_handle();
++}
++catch (std::exception const& e)
++{
++    MIR_LOG_UNCAUGHT_EXCEPTION(e);
++    abort();
++}
++
++MirBlob* pointer_drag_and_drop(MirPointerEvent const* event)
++try
++{
++    return event->dnd_handle();
++}
++catch (std::exception const& e)
++{
++    MIR_LOG_UNCAUGHT_EXCEPTION(e);
++    abort();
++}
++
++MirDragAndDropV1 const impl{
++    &request_drag_and_drop,
++    &set_start_drag_and_drop_callback,
++    &start_drag_and_drop,
++    &pointer_drag_and_drop};
++}
++
++MirDragAndDropV1 const* const mir::drag_and_drop::v1 = &impl;
 === added file 'src/client/drag_and_drop.h'
 --- src/client/drag_and_drop.h	1970-01-01 00:00:00 +0000
 +++ src/client/drag_and_drop.h	2017-03-17 15:49:43 +0000
@@ -0,0 +1,32 @@
++/*
++ * Copyright © 2017 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: Alan Griffiths <alan@octopull.co.uk>
++ */
++
++#ifndef MIR_DRAG_AND_DROP_V1_H
++#define MIR_DRAG_AND_DROP_V1_H
++
++typedef struct MirDragAndDropV1 MirDragAndDropV1;
++
++namespace mir
++{
++namespace drag_and_drop
++{
++extern MirDragAndDropV1 const* const v1;
++}
++}
++
++#endif //MIR_DRAG_AND_DROP_V1_H
 === modified file 'src/client/events/event_builders.cpp'
 --- src/client/events/event_builders.cpp	2017-02-15 13:36:35 +0000
 +++ src/client/events/event_builders.cpp	2017-03-17 15:49:43 +0000
@@ -110,6 +110,20 @@
      return make_uptr_event(e);
+ }
++auto mev::make_start_drag_and_drop_event(frontend::SurfaceId const& surface_id, std::vector<uint8_t> const& handle)
++    -> EventUPtr
++{
++    auto e = new_event<MirWindowEvent>();
++
++    e->set_id(surface_id.as_value());
++    e->set_attrib(mir_window_attribs);
++    e->set_value(0);
++    e->set_dnd_handle(handle);
++
++    return make_uptr_event(e);
++
++}
++
  mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id)
+ {
      auto e = new_event<MirCloseWindowEvent>();
@@ -450,3 +464,14 @@
          BOOST_THROW_EXCEPTION(std::invalid_argument("Event has no window id."));
+     }
+ }
++
++void mev::set_drag_and_drop_handle(MirEvent& event, std::vector<uint8_t> const& handle)
++{
++    if (event.type() == mir_event_type_input)
++    {
++        auto const input_event = event.to_input();
++        if (mir_input_event_get_type(input_event) == mir_input_event_type_pointer)
++            const_cast<MirPointerEvent*>(mir_input_event_get_pointer_event(input_event))->set_dnd_handle(handle);
++    }
++}
++
 === modified file 'src/client/mir_blob.cpp'
 --- src/client/mir_blob.cpp	2017-01-18 02:29:37 +0000
 +++ src/client/mir_blob.cpp	2017-03-17 15:49:43 +0000
@@ -16,6 +16,7 @@
   * Authored by: Alan Griffiths <alan@octopull.co.uk>
   */
++#include "mir_blob.h"
  #include "display_configuration.h"
  #include "mir_toolkit/mir_blob.h"
@@ -25,14 +26,6 @@
  namespace mp = mir::protobuf;
--struct MirBlob
--{
--    virtual size_t size() const = 0;
--    virtual void const* data() const = 0;
--
--    virtual ~MirBlob() = default;
--};
--
  namespace
+ {
  struct MirManagedBlob : MirBlob
 === modified file 'src/client/mir_connection.cpp'
 --- src/client/mir_connection.cpp	2017-03-14 04:41:33 +0000
 +++ src/client/mir_connection.cpp	2017-03-17 15:49:43 +0000
@@ -17,6 +17,7 @@
   */
  #include "mir_connection.h"
++#include "drag_and_drop.h"
  #include "mir_surface.h"
  #include "mir_prompt_session.h"
  #include "mir_toolkit/extensions/graphics_module.h"
@@ -1451,6 +1452,9 @@
      if (!strcmp(name, "mir_extension_graphics_module") && (version == 1) && graphics_module_extension.is_set())
          return &graphics_module_extension.value();
++    if (!strcmp(name, "mir_drag_and_drop") && (version == 1))
++        return const_cast<MirDragAndDropV1*>(mir::drag_and_drop::v1);
++
      return platform->request_interface(name, version);
+ }
 === modified file 'src/client/mir_surface.cpp'
 --- src/client/mir_surface.cpp	2017-03-14 04:41:33 +0000
 +++ src/client/mir_surface.cpp	2017-03-17 15:49:43 +0000
@@ -24,6 +24,7 @@
  #include "connection_surface_map.h"
  #include "mir_toolkit/mir_client_library.h"
++#include "mir_toolkit/mir_blob.h"
  #include "mir/frontend/client_constants.h"
  #include "mir/client_buffer.h"
  #include "mir/mir_buffer_stream.h"
@@ -32,6 +33,7 @@
  #include "mir/cookie/cookie.h"
  #include "mir_cookie.h"
  #include "mir/time/posix_timestamp.h"
++#include "mir/events/surface_event.h"
  #include <cassert>
  #include <unistd.h>
@@ -493,7 +495,14 @@
          auto sev = mir_event_get_window_event(&e);
          auto a = mir_window_event_get_attribute(sev);
          if (a < mir_window_attribs)
++        {
              attrib_cache[a] = mir_window_event_get_attribute_value(sev);
++        }
++        else
++        {
++            handle_drag_and_drop_start_callback(sev);
++            return;
++        }
          break;
+     }
      case mir_event_type_input:
@@ -598,6 +607,29 @@
          google::protobuf::NewCallback(google::protobuf::DoNothing));
+ }
++void MirSurface::request_drag_and_drop(MirCookie const* cookie)
++{
++    mp::RequestAuthority authority;
++
++    std::unique_lock<decltype(mutex)> lock(mutex);
++    authority.mutable_surface_id()->set_value(surface->id().value());
++
++    auto const event_cookie = authority.mutable_cookie();
++
++    event_cookie->set_cookie(cookie->cookie().data(), cookie->size());
++
++    server->request_drag_and_drop(
++        &authority,
++        void_response.get(),
++        google::protobuf::NewCallback(google::protobuf::DoNothing));
++}
++
++void MirSurface::set_drag_and_drop_start_handler(std::function<void(MirWindowEvent const*)> const& callback)
++{
++    std::lock_guard<decltype(mutex)> lock(mutex);
++    handle_drag_and_drop_start_callback = callback;
++}
++
  MirBufferStream* MirSurface::get_buffer_stream()
+ {
      std::lock_guard<decltype(mutex)> lock(mutex);
 === modified file 'src/client/mir_surface.h'
 --- src/client/mir_surface.h	2017-02-15 14:45:41 +0000
 +++ src/client/mir_surface.h	2017-03-17 15:49:43 +0000
@@ -200,6 +200,8 @@
      MirWaitHandle* set_preferred_orientation(MirOrientationMode mode);
      void raise_surface(MirCookie const* cookie);
++    void request_drag_and_drop(MirCookie const* cookie);
++    void set_drag_and_drop_start_handler(std::function<void(MirWindowEvent const*)> const& callback);
      MirWaitHandle* configure_cursor(MirCursorConfiguration const* cursor);
@@ -262,6 +264,8 @@
      std::shared_ptr<mir::client::FrameClock> const frame_clock;
      std::function<void(MirEvent const*)> handle_event_callback;
++    std::function<void(MirWindowEvent const*)> handle_drag_and_drop_start_callback = [](auto){};
++
      std::shared_ptr<mir::dispatch::ThreadedDispatcher> input_thread;
      //a bit batty, but the creation handle has to exist for as long as the MirSurface does,
 === modified file 'src/client/rpc/mir_display_server.cpp'
 --- src/client/rpc/mir_display_server.cpp	2017-02-15 07:38:33 +0000
 +++ src/client/rpc/mir_display_server.cpp	2017-03-17 15:49:43 +0000
@@ -238,6 +238,15 @@
+ {
      channel->call_method(std::string(__func__), request, response, done);
+ }
++
++void mclr::DisplayServer::request_drag_and_drop(
++    mir::protobuf::RequestAuthority const* request,
++    mir::protobuf::Void* response,
++    google::protobuf::Closure* done)
++{
++    channel->call_method(std::string(__func__), request, response, done);
++}
++
  void mclr::DisplayServer::apply_input_configuration(
      mir::protobuf::InputConfigurationRequest const* request,
      mir::protobuf::Void* response,
 === modified file 'src/client/rpc/mir_display_server.h'
 --- src/client/rpc/mir_display_server.h	2017-02-15 07:38:33 +0000
 +++ src/client/rpc/mir_display_server.h	2017-03-17 15:49:43 +0000
@@ -155,6 +155,10 @@
          mir::protobuf::RaiseRequest const* request,
          mir::protobuf::Void* response,
          google::protobuf::Closure* done) override;
++    void request_drag_and_drop(
++        mir::protobuf::RequestAuthority const* request,
++        mir::protobuf::Void* response,
++        google::protobuf::Closure* done) override;
      void apply_input_configuration(
          mir::protobuf::InputConfigurationRequest const* request,
          mir::protobuf::Void* response,
 === modified file 'src/client/symbols.map'
 --- src/client/symbols.map	2017-03-14 04:41:33 +0000
 +++ src/client/symbols.map	2017-03-17 15:49:43 +0000
@@ -604,6 +604,8 @@
    global:
      extern "C++" {
        mir::events::set_window_id*;
++      mir::events::make_start_drag_and_drop_event*;
++      mir::events::set_drag_and_drop_handle*;
      };
  } MIR_CLIENT_DETAIL_0.26.1;
 === modified file 'src/common/events/pointer_event.cpp'
 --- src/common/events/pointer_event.cpp	2016-11-07 23:02:26 +0000
 +++ src/common/events/pointer_event.cpp	2017-03-17 15:49:43 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2016 Canonical Ltd.
++ * Copyright © 2016-2017 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,
@@ -16,10 +16,11 @@
   * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
   */
++#include "mir/events/pointer_event.h"
++#include "mir_blob.h"
++
  #include <boost/throw_exception.hpp>
--#include "mir/events/pointer_event.h"
--
  MirPointerEvent::MirPointerEvent()
+ {
      event.initInput();
@@ -132,3 +133,40 @@
+ {
      event.getInput().getPointer().setAction(static_cast<mir::capnp::PointerEvent::PointerAction>(action));
+ }
++
++void MirPointerEvent::set_dnd_handle(std::vector<uint8_t> const& handle)
++{
++    event.getInput().getPointer().initDndHandle(handle.size());
++    event.getInput().getPointer().setDndHandle(::kj::ArrayPtr<uint8_t const>{&*begin(handle), &*end(handle)});
++}
++
++namespace
++{
++struct MyMirBlob : MirBlob
++{
++
++    size_t size() const override { return data_.size(); }
++    virtual void const* data() const override { return data_.data(); }
++
++    std::vector<uint8_t> data_;
++};
++}
++
++MirBlob* MirPointerEvent::dnd_handle() const
++{
++    auto const reader = event.asReader().getInput().getPointer();
++
++    if (!reader.hasDndHandle())
++        return nullptr;
++
++    auto const dnd_handle = reader.getDndHandle();
++
++    auto blob = std::make_unique<MyMirBlob>();
++    blob->data_.reserve(dnd_handle.size());
++
++    // Can't use std::copy() as the CapnP iterators don't provide an iterator category
++    for (auto p = dnd_handle.begin(); p != dnd_handle.end(); ++p)
++        blob->data_.push_back(*p);
++
++    return blob.release();
++}
 === modified file 'src/common/events/surface_event.cpp'
 --- src/common/events/surface_event.cpp	2017-01-23 03:38:33 +0000
 +++ src/common/events/surface_event.cpp	2017-03-17 15:49:43 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2016 Canonical Ltd.
++ * Copyright © 2016-2017 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,
@@ -17,6 +17,7 @@
   */
  #include "mir/events/surface_event.h"
++#include "mir_blob.h"
  // MirSurfaceEvent is a deprecated type, but we need to implement it
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -55,3 +56,40 @@
+ {
      event.getSurface().setValue(value);
+ }
++
++void MirSurfaceEvent::set_dnd_handle(std::vector<uint8_t> const& handle)
++{
++    event.getSurface().initDndHandle(handle.size());
++    event.getSurface().setDndHandle(::kj::ArrayPtr<uint8_t const>{&*begin(handle), &*end(handle)});
++}
++
++namespace
++{
++struct MyMirBlob : MirBlob
++{
++
++    size_t size() const override { return data_.size(); }
++    virtual void const* data() const override { return data_.data(); }
++
++    std::vector<uint8_t> data_;
++};
++}
++
++MirBlob* MirSurfaceEvent::dnd_handle() const
++{
++    if (!event.asReader().getSurface().hasDndHandle())
++        return nullptr;
++
++    auto blob = std::make_unique<MyMirBlob>();
++
++    auto reader = event.asReader().getSurface().getDndHandle();
++
++    blob->data_.reserve(reader.size());
++
++    // Can't use std::copy() as the CapnP iterators don't provide an iterator category
++    for (auto p = reader.begin(); p != reader.end(); ++p)
++        blob->data_.push_back(*p);
++
++    return blob.release();
++}
++
 === modified file 'src/common/symbols.map'
 --- src/common/symbols.map	2017-02-28 08:53:57 +0000
 +++ src/common/symbols.map	2017-03-17 15:49:43 +0000
@@ -432,5 +432,9 @@
        MirInputEvent::window_id*;
        MirKeyboardEvent::set_text*;
        MirKeyboardEvent::text*;
++      MirPointerEvent::dnd_handle*;
++      MirPointerEvent::set_dnd_handle*;
++      MirSurfaceEvent::dnd_handle*;
++      MirSurfaceEvent::set_dnd_handle*;
    };
  } MIR_COMMON_0.26;
 === modified file 'src/include/common/mir/events/pointer_event.h'
 --- src/include/common/mir/events/pointer_event.h	2016-09-22 19:21:34 +0000
 +++ src/include/common/mir/events/pointer_event.h	2017-03-17 15:49:43 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2016 Canonical Ltd.
++ * Copyright © 2016-2017 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,
@@ -21,6 +21,8 @@
  #include "mir/events/input_event.h"
++typedef struct MirBlob MirBlob;
++
  struct MirPointerEvent : MirInputEvent
+ {
      MirPointerEvent();
@@ -60,6 +62,9 @@
      MirPointerButtons buttons() const;
      void set_buttons(MirPointerButtons buttons);
++
++    void set_dnd_handle(std::vector<uint8_t> const& handle);
++    MirBlob* dnd_handle() const;
  private:
  };
 === modified file 'src/include/common/mir/events/surface_event.h'
 --- src/include/common/mir/events/surface_event.h	2017-01-18 02:29:37 +0000
 +++ src/include/common/mir/events/surface_event.h	2017-03-17 15:49:43 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2016 Canonical Ltd.
++ * Copyright © 2016-2017 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,
@@ -21,6 +21,8 @@
  #include "mir/events/event.h"
++typedef struct MirBlob MirBlob;
++
  struct MirSurfaceEvent : MirEvent
+ {
      MirSurfaceEvent();
@@ -33,6 +35,9 @@
      int value() const;
      void set_value(int value);
++
++    void set_dnd_handle(std::vector<uint8_t> const& handle);
++    MirBlob* dnd_handle() const;
  };
  #endif /* MIR_COMMON_SURFACE_EVENT_H_ */
 === modified file 'src/include/common/mir/protobuf/display_server.h'
 --- src/include/common/mir/protobuf/display_server.h	2017-02-15 07:38:33 +0000
 +++ src/include/common/mir/protobuf/display_server.h	2017-03-17 15:49:43 +0000
@@ -151,6 +151,10 @@
          mir::protobuf::RaiseRequest const* request,
          mir::protobuf::Void* response,
          google::protobuf::Closure* done) = 0;
++    virtual void request_drag_and_drop(
++        mir::protobuf::RequestAuthority const* request,
++        mir::protobuf::Void* response,
++        google::protobuf::Closure* done) = 0;
      virtual void apply_input_configuration(
          mir::protobuf::InputConfigurationRequest const* request,
          mir::protobuf::Void* response,
 === added file 'src/include/common/mir_blob.h'
 --- src/include/common/mir_blob.h	1970-01-01 00:00:00 +0000
 +++ src/include/common/mir_blob.h	2017-03-17 15:49:43 +0000
@@ -0,0 +1,32 @@
++/*
++ * Copyright © 2017 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: Alan Griffiths <alan@octopull.co.uk>
++ */
++
++#ifndef MIR_MIR_BLOB_H_H
++#define MIR_MIR_BLOB_H_H
++
++#include <stddef.h>
++
++struct MirBlob
++{
++    virtual size_t size() const = 0;
++    virtual void const* data() const = 0;
++
++    virtual ~MirBlob() = default;
++};
++
++#endif //MIR_MIR_BLOB_H_H
 === modified file 'src/include/server/mir/frontend/shell.h'
 --- src/include/server/mir/frontend/shell.h	2017-01-18 02:29:37 +0000
 +++ src/include/server/mir/frontend/shell.h	2017-03-17 15:49:43 +0000
@@ -87,6 +87,11 @@
          SurfaceId surface_id,
          uint64_t timestamp) = 0;
++    virtual void request_drag_and_drop(
++        std::shared_ptr<Session> const& session,
++        SurfaceId surface_id,
++        uint64_t timestamp) = 0;
++
  protected:
      Shell() = default;
      Shell(const Shell&) = delete;
 === modified file 'src/include/server/mir/scene/surface_event_source.h'
 --- src/include/server/mir/scene/surface_event_source.h	2017-02-15 13:36:35 +0000
 +++ src/include/server/mir/scene/surface_event_source.h	2017-03-17 15:49:43 +0000
@@ -51,6 +51,7 @@
                          std::string const& variant, std::string const& options) override;
      void placed_relative(geometry::Rectangle const& placement) override;
      void input_consumed(MirEvent const* event) override;
++    void start_drag_and_drop(std::vector<uint8_t> const& handle) override;
  private:
      frontend::SurfaceId const id;
 === modified file 'src/include/server/mir/scene/surface_observers.h'
 --- src/include/server/mir/scene/surface_observers.h	2017-02-15 13:36:35 +0000
 +++ src/include/server/mir/scene/surface_observers.h	2017-03-17 15:49:43 +0000
@@ -51,6 +51,7 @@
      void cursor_image_removed() override;
      void placed_relative(geometry::Rectangle const& placement) override;
      void input_consumed(MirEvent const* event) override;
++    void start_drag_and_drop(std::vector<uint8_t> const& handle) override;
  };
+ }
 === modified file 'src/include/server/mir/shell/basic_window_manager.h'
 --- src/include/server/mir/shell/basic_window_manager.h	2017-01-18 02:29:37 +0000
 +++ src/include/server/mir/shell/basic_window_manager.h	2017-03-17 15:49:43 +0000
@@ -65,6 +65,9 @@
      virtual void raise_tree(std::shared_ptr<scene::Surface> const& root) = 0;
++    virtual void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) = 0;
++    virtual void clear_drag_and_drop_handle() = 0;
++
      virtual ~WindowManagerTools() = default;
      WindowManagerTools() = default;
      WindowManagerTools(WindowManagerTools const&) = delete;
@@ -107,6 +110,10 @@
          std::shared_ptr<scene::Session> const& session,
          std::shared_ptr<scene::Surface> const& surface) = 0;
++    virtual void handle_request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface) = 0;
++
      virtual ~WindowManagementPolicy() = default;
      WindowManagementPolicy() = default;
      WindowManagementPolicy(WindowManagementPolicy const&) = delete;
@@ -163,6 +170,11 @@
          std::shared_ptr<scene::Surface> const& surface,
          uint64_t timestamp) override;
++    void handle_request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface,
++        uint64_t timestamp) override;
++
      int set_surface_attribute(
          std::shared_ptr<scene::Session> const& /*session*/,
          std::shared_ptr<scene::Surface> const& surface,
@@ -192,6 +204,9 @@
      void raise_tree(std::shared_ptr<scene::Surface> const& root) override;
++    void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) override;
++    void clear_drag_and_drop_handle() override;
++
  private:
      shell::FocusController* const focus_controller;
      std::unique_ptr<WindowManagementPolicy> const policy;
 === modified file 'src/include/server/mir/shell/canonical_window_manager.h'
 --- src/include/server/mir/shell/canonical_window_manager.h	2017-01-18 02:29:37 +0000
 +++ src/include/server/mir/shell/canonical_window_manager.h	2017-03-17 15:49:43 +0000
@@ -75,6 +75,10 @@
          std::shared_ptr<scene::Session> const& session,
          std::shared_ptr<scene::Surface> const& surface) override;
++    void handle_request_drag_and_drop(
++        std::shared_ptr<scene::Session> const& session,
++        std::shared_ptr<scene::Surface> const& surface) override;
++
  private:
      static const int modifier_mask =
          mir_input_event_modifier_alt |
 === modified file 'src/protobuf/mir_protobuf.proto'
 --- src/protobuf/mir_protobuf.proto	2017-03-14 04:41:33 +0000
 +++ src/protobuf/mir_protobuf.proto	2017-03-17 15:49:43 +0000
@@ -444,6 +444,11 @@
    required SurfaceId surface_id = 2;
+ }
++message RequestAuthority {
++  required Cookie cookie = 1;
++  required SurfaceId surface_id = 2;
++}
++
  message InputDevices {
    repeated InputDeviceInfo device_info = 1;
+ }
 === modified file 'src/protobuf/symbols.map'
 --- src/protobuf/symbols.map	2017-02-15 07:38:33 +0000
 +++ src/protobuf/symbols.map	2017-03-17 15:49:43 +0000
@@ -1112,3 +1112,29 @@
      vtable?for?mir::protobuf::PromptSession;
    };
  } MIR_PROTOBUF_0.22;
++
++MIR_PROTOBUF_0.27 {
++ global:
++  extern "C++" {
++    mir::protobuf::RequestAuthority::ByteSize*;
++    mir::protobuf::RequestAuthority::CheckTypeAndMergeFrom*;
++    mir::protobuf::RequestAuthority::Clear*;
++    mir::protobuf::RequestAuthority::CopyFrom*;
++    mir::protobuf::RequestAuthority::default_instance*;
++    mir::protobuf::RequestAuthority::DiscardUnknownFields*;
++    mir::protobuf::RequestAuthority::GetTypeName*;
++    mir::protobuf::RequestAuthority::IsInitialized*;
++    mir::protobuf::RequestAuthority::kCookieFieldNumber*;
++    mir::protobuf::RequestAuthority::kSurfaceIdFieldNumber*;
++    mir::protobuf::RequestAuthority::MergeFrom*;
++    mir::protobuf::RequestAuthority::MergePartialFromCodedStream*;
++    mir::protobuf::RequestAuthority::New*;
++    mir::protobuf::RequestAuthority::?RequestAuthority*;
++    mir::protobuf::RequestAuthority::RequestAuthority*;
++    mir::protobuf::RequestAuthority::SerializeWithCachedSizes*;
++    mir::protobuf::RequestAuthority::Swap*;
++    non-virtual?thunk?to?mir::protobuf::RequestAuthority::?RequestAuthority*;
++    typeinfo?for?mir::protobuf::RequestAuthority;
++    vtable?for?mir::protobuf::RequestAuthority;
++  };
++} MIR_PROTOBUF_0.26;
 === modified file 'src/server/frontend/protobuf_message_processor.cpp'
 --- src/server/frontend/protobuf_message_processor.cpp	2017-02-15 07:38:33 +0000
 +++ src/server/frontend/protobuf_message_processor.cpp	2017-03-17 15:49:43 +0000
@@ -305,6 +305,10 @@
+         {
              invoke(this, display_server.get(), &protobuf::DisplayServer::stop_prompt_session, invocation);
+         }
++        else if ("request_drag_and_drop" == invocation.method_name())
++        {
++            invoke(this, display_server.get(), &protobuf::DisplayServer::request_drag_and_drop, invocation);
++        }
          else if ("disconnect" == invocation.method_name())
+         {
              invoke(this, display_server.get(), &DisplayServer::disconnect, invocation);
 === modified file 'src/server/frontend/session_mediator.cpp'
 --- src/server/frontend/session_mediator.cpp	2017-03-14 04:41:33 +0000
 +++ src/server/frontend/session_mediator.cpp	2017-03-17 15:49:43 +0000
@@ -1175,6 +1175,26 @@
      done->Run();
+ }
++void mir::frontend::SessionMediator::request_drag_and_drop(mir::protobuf::RequestAuthority const* request,
++    mir::protobuf::Void*, google::protobuf::Closure* done)
++{
++    auto const session = weak_session.lock();
++    if (!session)
++        BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
++
++    auto const cookie     = request->cookie();
++    auto const surface_id = request->surface_id();
++
++    auto cookie_string = cookie.cookie();
++
++    std::vector<uint8_t> cookie_bytes(cookie_string.begin(), cookie_string.end());
++    auto const cookie_ptr = cookie_authority->make_cookie(cookie_bytes);
++
++    shell->request_drag_and_drop(session, mf::SurfaceId{surface_id.value()}, cookie_ptr->timestamp());
++
++    done->Run();
++}
++
  void mf::SessionMediator::apply_input_configuration(
      mir::protobuf::InputConfigurationRequest const* request,
      mir::protobuf::Void*,
@@ -1254,7 +1274,6 @@
          screencast_buffer_tracker.remove_session(id);
+ }
--
  auto mf::detail::PromptSessionStore::insert(std::shared_ptr<PromptSession> const& session) -> PromptSessionId
+ {
      std::lock_guard<decltype(mutex)> lock{mutex};
 === modified file 'src/server/frontend/session_mediator.h'
 --- src/server/frontend/session_mediator.h	2017-03-14 02:26:28 +0000
 +++ src/server/frontend/session_mediator.h	2017-03-17 15:49:43 +0000
@@ -249,6 +249,10 @@
          mir::protobuf::RaiseRequest const* request,
          mir::protobuf::Void*,
          google::protobuf::Closure* done) override;
++    void request_drag_and_drop(
++        mir::protobuf::RequestAuthority const* request,
++        mir::protobuf::Void*,
++        google::protobuf::Closure* done) override;
      void apply_input_configuration(
          mir::protobuf::InputConfigurationRequest const* request,
          mir::protobuf::Void* response,
 === modified file 'src/server/frontend/shell_wrapper.cpp'
 --- src/server/frontend/shell_wrapper.cpp	2017-01-18 02:29:37 +0000
 +++ src/server/frontend/shell_wrapper.cpp	2017-03-17 15:49:43 +0000
@@ -106,3 +106,11 @@
+ {
      wrapped->raise_surface(session, surface_id, timestamp);
+ }
++
++void mf::ShellWrapper::request_drag_and_drop(
++    std::shared_ptr<Session> const& session,
++    SurfaceId surface_id,
++    uint64_t timestamp)
++{
++    wrapped->request_drag_and_drop(session, surface_id, timestamp);
++}
 === modified file 'src/server/frontend/shell_wrapper.h'
 --- src/server/frontend/shell_wrapper.h	2017-01-18 02:29:37 +0000
 +++ src/server/frontend/shell_wrapper.h	2017-03-17 15:49:43 +0000
@@ -80,6 +80,11 @@
          SurfaceId surface_id,
          uint64_t timestamp) override;
++    void request_drag_and_drop(
++        std::shared_ptr<Session> const& session,
++        SurfaceId surface_id,
++        uint64_t timestamp) override;
++
  protected:
      std::shared_ptr<Shell> const wrapped;
  };
 === modified file 'src/server/input/null_input_targeter.h'
 --- src/server/input/null_input_targeter.h	2017-02-15 14:45:41 +0000
 +++ src/server/input/null_input_targeter.h	2017-03-17 15:49:43 +0000
@@ -38,6 +38,9 @@
      void clear_focus() override
+     {
+     }
++
++    void set_drag_and_drop_handle(std::vector<uint8_t> const&) override {}
++    void clear_drag_and_drop_handle() override {}
  };
+ }
 === modified file 'src/server/input/surface_input_dispatcher.cpp'
 --- src/server/input/surface_input_dispatcher.cpp	2017-01-18 02:29:37 +0000
 +++ src/server/input/surface_input_dispatcher.cpp	2017-03-17 15:49:43 +0000
@@ -70,7 +70,10 @@
      std::function<void(ms::Surface*)> const on_removed;
  };
--void deliver_without_relative_motion(std::shared_ptr<mi::Surface> const& surface, MirEvent const* ev)
++void deliver_without_relative_motion(
++    std::shared_ptr<mi::Surface> const& surface,
++    MirEvent const* ev,
++    std::vector<uint8_t> const& drag_and_drop_handle)
+ {
      auto const* input_ev = mir_event_get_input_event(ev);
      auto const* pev = mir_input_event_get_pointer_event(input_ev);
@@ -98,12 +101,21 @@
 .0f);
      mev::transform_positions(*to_deliver, geom::Displacement{bounds.top_left.x.as_int(), bounds.top_left.y.as_int()});
++    if (!drag_and_drop_handle.empty())
++        mev::set_drag_and_drop_handle(*to_deliver, drag_and_drop_handle);
      surface->consume(to_deliver.get());
+ }
--void deliver(std::shared_ptr<mi::Surface> const& surface, MirEvent const* ev)
++void deliver(
++    std::shared_ptr<mi::Surface> const& surface,
++    MirEvent const* ev,
++    std::vector<uint8_t> const& drag_and_drop_handle)
+ {
      auto to_deliver = mev::clone_event(*ev);
++
++    if (!drag_and_drop_handle.empty())
++        mev::set_drag_and_drop_handle(*to_deliver, drag_and_drop_handle);
++
      auto const& bounds = surface->input_bounds();
      mev::transform_positions(*to_deliver, geom::Displacement{bounds.top_left.x.as_int(), bounds.top_left.y.as_int()});
      surface->consume(to_deliver.get());
@@ -243,6 +255,8 @@
          mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_x),
          mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_y));
++    if (!drag_and_drop_handle.empty())
++        mev::set_drag_and_drop_handle(*event, drag_and_drop_handle);
      surface->consume(event.get());
+ }
@@ -270,12 +284,17 @@
      if (pointer_state.gesture_owner)
+     {
--        deliver(pointer_state.gesture_owner, ev);
--
--        if (is_gesture_terminator(pev))
++        deliver(pointer_state.gesture_owner, ev, drag_and_drop_handle);
++
++        auto const gesture_terminated = is_gesture_terminator(pev);
++
++        if (gesture_terminated)
+         {
              pointer_state.gesture_owner.reset();
++        }
++        if (gesture_terminated || !drag_and_drop_handle.empty())
++        {
              auto target = find_target_surface(event_x_y);
              if (pointer_state.current_target != target)
@@ -286,6 +305,9 @@
                  pointer_state.current_target = target;
                  if (target)
                      send_enter_exit_event(target, pev, mir_pointer_action_enter);
++
++                if (!gesture_terminated)
++                    pointer_state.gesture_owner = target;
+             }
+         }
@@ -323,11 +345,11 @@
          if (sent_ev)
+         {
              if (action != mir_pointer_action_motion)
--                deliver_without_relative_motion(target, ev);
++                deliver_without_relative_motion(target, ev, drag_and_drop_handle);
+         }
          else
+         {
--            deliver(target, ev);
++            deliver(target, ev, drag_and_drop_handle);
+         }
          return true;
+     }
@@ -383,7 +405,7 @@
      if (gesture_owner)
+     {
--        deliver(gesture_owner, ev);
++        deliver(gesture_owner, ev, drag_and_drop_handle);
          if (is_gesture_end(tev))
              gesture_owner.reset();
@@ -450,3 +472,15 @@
      set_focus_locked(lg, nullptr);
+ }
++void mir::input::SurfaceInputDispatcher::set_drag_and_drop_handle(std::vector<uint8_t> const& handle)
++{
++    std::lock_guard<std::mutex> lg(dispatcher_mutex);
++    drag_and_drop_handle = handle;
++}
++
++void mir::input::SurfaceInputDispatcher::clear_drag_and_drop_handle()
++{
++    std::lock_guard<std::mutex> lg(dispatcher_mutex);
++    drag_and_drop_handle.clear();
++}
++
 === modified file 'src/server/input/surface_input_dispatcher.h'
 --- src/server/input/surface_input_dispatcher.h	2016-10-05 13:18:38 +0000
 +++ src/server/input/surface_input_dispatcher.h	2017-03-17 15:49:43 +0000
@@ -54,7 +54,10 @@
      // InputTargeter
      void set_focus(std::shared_ptr<input::Surface> const& target) override;
      void clear_focus() override;
--
++
++    void set_drag_and_drop_handle(std::vector<uint8_t> const& handle) override;
++    void clear_drag_and_drop_handle() override;
++
  private:
      void device_reset(MirInputDeviceId reset_device_id, std::chrono::nanoseconds when);
      bool dispatch_key(MirEvent const* kev);
@@ -92,6 +95,7 @@
      std::mutex dispatcher_mutex;
      std::weak_ptr<input::Surface> focus_surface;
++    std::vector<uint8_t> drag_and_drop_handle;
      bool started;
  };
 === modified file 'src/server/scene/basic_surface.cpp'
 --- src/server/scene/basic_surface.cpp	2017-02-15 14:45:41 +0000
 +++ src/server/scene/basic_surface.cpp	2017-03-17 15:49:43 +0000
@@ -144,6 +144,12 @@
                   { observer->input_consumed(event); });
+ }
++void ms::SurfaceObservers::start_drag_and_drop(std::vector<uint8_t> const& handle)
++{
++    for_each([&](std::shared_ptr<SurfaceObserver> const& observer)
++                 { observer->start_drag_and_drop(handle); });
++}
++
  struct ms::CursorStreamImageAdapter
+ {
@@ -923,3 +929,8 @@
+ {
      observers.placed_relative(placement);
+ }
++
++void mir::scene::BasicSurface::start_drag_and_drop(std::vector<uint8_t> const& handle)
++{
++    observers.start_drag_and_drop(handle);
++}
 === modified file 'src/server/scene/basic_surface.h'
 --- src/server/scene/basic_surface.h	2017-02-15 14:45:41 +0000
 +++ src/server/scene/basic_surface.h	2017-03-17 15:49:43 +0000
@@ -139,6 +139,7 @@
      void set_confine_pointer_state(MirPointerConfinementState state) override;
      MirPointerConfinementState confine_pointer_state() const override;
      void placed_relative(geometry::Rectangle const& placement) override;
++    void start_drag_and_drop(std::vector<uint8_t> const& handle) override;
  private:
      bool visible(std::unique_lock<std::mutex>&) const;
 === modified file 'src/server/scene/legacy_surface_change_notification.cpp'
 --- src/server/scene/legacy_surface_change_notification.cpp	2017-02-15 13:36:35 +0000
 +++ src/server/scene/legacy_surface_change_notification.cpp	2017-03-17 15:49:43 +0000
@@ -108,3 +108,7 @@
  void ms::LegacySurfaceChangeNotification::input_consumed(MirEvent const*)
+ {
+ }
++
++void ms::LegacySurfaceChangeNotification::start_drag_and_drop(std::vector<uint8_t> const& /*handle*/)
++{
++}
 \ No newline at end of file
 === modified file 'src/server/scene/legacy_surface_change_notification.h'
 --- src/server/scene/legacy_surface_change_notification.h	2017-02-15 13:36:35 +0000
 +++ src/server/scene/legacy_surface_change_notification.h	2017-03-17 15:49:43 +0000
@@ -51,6 +51,7 @@
      void cursor_image_removed() override;
      void placed_relative(geometry::Rectangle const& placement) override;
      void input_consumed(MirEvent const* event) override;
++    void start_drag_and_drop(std::vector<uint8_t> const& handle) override;
  private:
      std::function<void()> const notify_scene_change;
 === modified file 'src/server/scene/null_surface_observer.cpp'
 --- src/server/scene/null_surface_observer.cpp	2017-02-15 13:36:35 +0000
 +++ src/server/scene/null_surface_observer.cpp	2017-03-17 15:49:43 +0000
@@ -41,3 +41,4 @@
  void ms::NullSurfaceObserver::cursor_image_removed() {}
  void ms::NullSurfaceObserver::placed_relative(geometry::Rectangle const& /*placement*/)  {}
  void ms::NullSurfaceObserver::input_consumed(MirEvent const* /*event*/)  {}
++void ms::NullSurfaceObserver::start_drag_and_drop(std::vector<uint8_t> const& /*handle*/)  {}
 === modified file 'src/server/scene/surface_event_source.cpp'
 --- src/server/scene/surface_event_source.cpp	2017-02-15 13:36:35 +0000
 +++ src/server/scene/surface_event_source.cpp	2017-03-17 15:49:43 +0000
@@ -101,3 +101,8 @@
      mev::set_window_id(*ev, id.as_value());
      event_sink->handle_event(*ev);
+ }
++
++void ms::SurfaceEventSource::start_drag_and_drop(std::vector<uint8_t> const& handle)
++{
++    event_sink->handle_event(*mev::make_start_drag_and_drop_event(id, handle));
++}
 === modified file 'src/server/shell/abstract_shell.cpp'
 --- src/server/shell/abstract_shell.cpp	2017-03-10 19:47:57 +0000
 +++ src/server/shell/abstract_shell.cpp	2017-03-17 15:49:43 +0000
@@ -251,6 +251,14 @@
      window_manager->handle_raise_surface(session, surface, timestamp);
+ }
++void msh::AbstractShell::request_drag_and_drop(
++    std::shared_ptr<scene::Session> const& session,
++    std::shared_ptr<scene::Surface> const& surface,
++    uint64_t timestamp)
++{
++    window_manager->handle_request_drag_and_drop(session, surface, timestamp);
++}
++
  void msh::AbstractShell::focus_next_session()
+ {
      std::unique_lock<std::mutex> lock(focus_mutex);
@@ -401,3 +409,12 @@
      report->surfaces_raised(surfaces);
+ }
++void msh::AbstractShell::set_drag_and_drop_handle(std::vector<uint8_t> const& handle)
++{
++    input_targeter->set_drag_and_drop_handle(handle);
++}
++
++void msh::AbstractShell::clear_drag_and_drop_handle()
++{
++    input_targeter->clear_drag_and_drop_handle();
++}
 === modified file 'src/server/shell/basic_window_manager.cpp'
 --- src/server/shell/basic_window_manager.cpp	2017-01-18 02:29:37 +0000
 +++ src/server/shell/basic_window_manager.cpp	2017-03-17 15:49:43 +0000
@@ -135,6 +135,16 @@
          policy->handle_raise_surface(session, surface);
+ }
++void msh::BasicWindowManager::handle_request_drag_and_drop(
++    std::shared_ptr<scene::Session> const& session,
++    std::shared_ptr<scene::Surface> const& surface,
++    uint64_t timestamp)
++{
++    std::lock_guard<decltype(mutex)> lock(mutex);
++    if (timestamp >= last_input_event_timestamp)
++        policy->handle_request_drag_and_drop(session, surface);
++}
++
  int msh::BasicWindowManager::set_surface_attribute(
      std::shared_ptr<scene::Session> const& /*session*/,
      std::shared_ptr<scene::Surface> const& surface,
@@ -309,3 +319,14 @@
+         }
+     }
+ }
++
++void mir::shell::BasicWindowManager::set_drag_and_drop_handle(std::vector<uint8_t> const& handle)
++{
++    focus_controller->set_drag_and_drop_handle(handle);
++}
++
++void mir::shell::BasicWindowManager::clear_drag_and_drop_handle()
++{
++    focus_controller->clear_drag_and_drop_handle();
++}
++
 === modified file 'src/server/shell/canonical_window_manager.cpp'
 --- src/server/shell/canonical_window_manager.cpp	2017-03-10 19:47:57 +0000
 +++ src/server/shell/canonical_window_manager.cpp	2017-03-17 15:49:43 +0000
@@ -24,6 +24,7 @@
  #include "mir/shell/surface_ready_observer.h"
  #include "mir/shell/display_layout.h"
++#include <uuid/uuid.h>
  #include <linux/input.h>
  #include <csignal>
@@ -583,6 +584,18 @@
      select_active_surface(surface);
+ }
++void msh::CanonicalWindowManagerPolicy::handle_request_drag_and_drop(
++    std::shared_ptr<ms::Session> const& /*session*/,
++    std::shared_ptr<ms::Surface> const& surface)
++{
++    uuid_t uuid;
++    uuid_generate(uuid);
++    std::vector<uint8_t> const handle{std::begin(uuid), std::end(uuid)};
++
++    surface->start_drag_and_drop(handle);
++    tools->set_drag_and_drop_handle(handle);
++}
++
  bool msh::CanonicalWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
+ {
      auto const action = mir_keyboard_event_action(event);
 === modified file 'src/server/shell/frontend_shell.cpp'
 --- src/server/shell/frontend_shell.cpp	2017-01-18 02:29:37 +0000
 +++ src/server/shell/frontend_shell.cpp	2017-03-17 15:49:43 +0000
@@ -157,3 +157,13 @@
      auto const surface = scene_session->surface(surface_id);
      wrapped->raise_surface(scene_session, surface, timestamp);
+ }
++
++void msh::FrontendShell::request_drag_and_drop(
++    std::shared_ptr<mf::Session> const& session,
++    mf::SurfaceId surface_id,
++    uint64_t timestamp)
++{
++    auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
++    auto const surface = scene_session->surface(surface_id);
++    wrapped->request_drag_and_drop(scene_session, surface, timestamp);
++}
 === modified file 'src/server/shell/frontend_shell.h'
 --- src/server/shell/frontend_shell.h	2017-01-18 02:29:37 +0000
 +++ src/server/shell/frontend_shell.h	2017-03-17 15:49:43 +0000
@@ -91,6 +91,11 @@
          std::shared_ptr<mf::Session> const& session,
          mf::SurfaceId surface_id,
          uint64_t timestamp) override;
++
++    void request_drag_and_drop(
++        std::shared_ptr<mf::Session> const& session,
++        mf::SurfaceId surface_id,
++        uint64_t timestamp) override;
  };
+ }
+ }
 === modified file 'src/server/shell/shell_wrapper.cpp'
 --- src/server/shell/shell_wrapper.cpp	2017-01-18 02:29:37 +0000
 +++ src/server/shell/shell_wrapper.cpp	2017-03-17 15:49:43 +0000
@@ -120,6 +120,14 @@
      wrapped->raise_surface(session, surface, timestamp);
+ }
++void msh::ShellWrapper::request_drag_and_drop(
++    std::shared_ptr<ms::Session> const& session,
++    std::shared_ptr<ms::Surface> const& surface,
++    uint64_t timestamp)
++{
++    wrapped->request_drag_and_drop(session, surface, timestamp);
++}
++
  void msh::ShellWrapper::add_display(geometry::Rectangle const& area)
+ {
      wrapped->add_display(area);
@@ -149,3 +157,13 @@
+ {
      return wrapped->raise(surfaces);
+ }
++
++void msh::ShellWrapper::set_drag_and_drop_handle(std::vector<uint8_t> const& handle)
++{
++    wrapped->set_drag_and_drop_handle(handle);
++}
++
++void msh::ShellWrapper::clear_drag_and_drop_handle()
++{
++    wrapped->clear_drag_and_drop_handle();
++}
 === modified file 'src/server/shell/system_compositor_window_manager.cpp'
 --- src/server/shell/system_compositor_window_manager.cpp	2017-01-18 02:29:37 +0000
 +++ src/server/shell/system_compositor_window_manager.cpp	2017-03-17 15:49:43 +0000
@@ -201,3 +201,10 @@
      uint64_t /*timestamp*/)
+ {
+ }
++
++void msh::SystemCompositorWindowManager::handle_request_drag_and_drop(
++    std::shared_ptr<ms::Session> const& /*session*/,
++    std::shared_ptr<ms::Surface> const& /*surface*/,
++    uint64_t /*timestamp*/)
++{
++}
 === modified file 'src/server/symbols.map'
 --- src/server/symbols.map	2017-03-15 10:38:02 +0000
 +++ src/server/symbols.map	2017-03-17 15:49:43 +0000
@@ -129,6 +129,7 @@
      mir::scene::NullSurfaceObserver::reception_mode_set_to*;
      mir::scene::NullSurfaceObserver::renamed*;
      mir::scene::NullSurfaceObserver::resized_to*;
++    mir::scene::NullSurfaceObserver::start_drag_and_drop*;
      mir::scene::NullSurfaceObserver::transformation_set_to*;
      mir::scene::Observer::?Observer*;
      mir::scene::Observer::Observer*;
@@ -293,6 +294,7 @@
      mir::shell::ShellReport::ShellReport*;
      mir::shell::ShellWrapper::add_display*;
      mir::shell::ShellWrapper::add_prompt_provider_for*;
++    mir::shell::ShellWrapper::clear_drag_and_drop_handle*;
      mir::shell::ShellWrapper::close_session*;
      mir::shell::ShellWrapper::create_surface*;
      mir::shell::ShellWrapper::destroy_surface*;
@@ -306,9 +308,11 @@
      mir::shell::ShellWrapper::raise*;
      mir::shell::ShellWrapper::raise_surface*;
      mir::shell::ShellWrapper::remove_display*;
++    mir::shell::ShellWrapper::request_drag_and_drop*;
      mir::shell::ShellWrapper::set_focus_to*;
      mir::shell::ShellWrapper::set_surface_attribute*;
      mir::shell::ShellWrapper::ShellWrapper*;
++    mir::shell::ShellWrapper::set_drag_and_drop_handle*;
      mir::shell::ShellWrapper::start_prompt_session_for*;
      mir::shell::ShellWrapper::stop_prompt_session*;
      mir::shell::ShellWrapper::surface_at*;
@@ -338,6 +342,7 @@
      mir::shell::SystemCompositorWindowManager::remove_display*;
      mir::shell::SystemCompositorWindowManager::remove_session*;
      mir::shell::SystemCompositorWindowManager::remove_surface*;
++    mir::shell::SystemCompositorWindowManager::handle_request_drag_and_drop*;
      mir::shell::SystemCompositorWindowManager::set_surface_attribute*;
      mir::shell::SystemCompositorWindowManager::SystemCompositorWindowManager*;
      mir::shell::WindowManager::operator*;
@@ -695,6 +700,7 @@
      mir::shell::CanonicalWindowManagerPolicy::handle_touch_event*;
      mir::shell::CanonicalWindowManagerPolicy::handle_pointer_event*;
      mir::shell::CanonicalWindowManagerPolicy::handle_raise_surface*;
++    mir::shell::CanonicalWindowManagerPolicy::handle_request_drag_and_drop*;
      typeinfo?for?mir::shell::CanonicalWindowManagerPolicy;
      vtable?for?mir::shell::CanonicalWindowManagerPolicy;
      VTT?for?mir::shell::CanonicalWindowManagerPolicy;
@@ -831,6 +837,7 @@
      mir::shell::BasicWindowManager::add_session*;
      mir::shell::BasicWindowManager::add_surface*;
      mir::shell::BasicWindowManager::BasicWindowManager*;
++    mir::shell::BasicWindowManager::clear_drag_and_drop_handle*;
      mir::shell::BasicWindowManager::find_session*;
      mir::shell::BasicWindowManager::focused_session*;
      mir::shell::BasicWindowManager::focused_surface*;
@@ -839,6 +846,7 @@
      mir::shell::BasicWindowManager::handle_keyboard_event*;
      mir::shell::BasicWindowManager::handle_pointer_event*;
      mir::shell::BasicWindowManager::handle_raise_surface*;
++    mir::shell::BasicWindowManager::handle_request_drag_and_drop*;
      mir::shell::BasicWindowManager::handle_touch_event*;
      mir::shell::BasicWindowManager::info_for*;
      mir::shell::BasicWindowManager::modify_surface*;
@@ -846,6 +854,7 @@
      mir::shell::BasicWindowManager::remove_display*;
      mir::shell::BasicWindowManager::remove_session*;
      mir::shell::BasicWindowManager::remove_surface*;
++    mir::shell::BasicWindowManager::set_drag_and_drop_handle*;
      mir::shell::BasicWindowManager::set_focus_to*;
      mir::shell::BasicWindowManager::set_surface_attribute*;
      mir::shell::BasicWindowManager::surface_at*;
@@ -856,6 +865,7 @@
      virtual?thunk?to?mir::shell::BasicWindowManager::handle_keyboard_event*;
      virtual?thunk?to?mir::shell::BasicWindowManager::handle_pointer_event*;
      virtual?thunk?to?mir::shell::BasicWindowManager::handle_raise_surface*;
++    virtual?thunk?to?mir::shell::BasicWindowManager::handle_request_drag_and_drop*;
      virtual?thunk?to?mir::shell::BasicWindowManager::handle_touch_event*;
      virtual?thunk?to?mir::shell::BasicWindowManager::modify_surface*;
      virtual?thunk?to?mir::shell::BasicWindowManager::remove_display*;
 === modified file 'tests/acceptance-tests/CMakeLists.txt'
 --- tests/acceptance-tests/CMakeLists.txt	2017-03-10 19:47:57 +0000
 +++ tests/acceptance-tests/CMakeLists.txt	2017-03-17 15:49:43 +0000
@@ -3,6 +3,8 @@
  set(
    SOURCES
++  drag_and_drop.cpp
++
    # Catch double-free bugs by wrapping close() and abort()ing on EBADF
    strict_close.cpp
 === added file 'tests/acceptance-tests/drag_and_drop.cpp'
 --- tests/acceptance-tests/drag_and_drop.cpp	1970-01-01 00:00:00 +0000
 +++ tests/acceptance-tests/drag_and_drop.cpp	2017-03-17 15:49:43 +0000
@@ -0,0 +1,624 @@
++/*
++ * Copyright © 2017 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: Alan Griffiths <alan@octopull.co.uk>
++ */
++
++#include <mir_toolkit/extensions/drag_and_drop.h>
++#include <mir_toolkit/mir_blob.h>
++
++#include <mir/geometry/displacement.h>
++#include <mir/input/input_device_info.h>
++#include <mir/input/device_capability.h>
++#include <mir/shell/shell.h>
++
++#include <mir_test_framework/connected_client_with_a_window.h>
++#include <mir_test_framework/fake_input_device.h>
++#include <mir_test_framework/stub_server_platform_factory.h>
++#include <mir/test/event_factory.h>
++#include <mir/test/signal.h>
++
++#include <gmock/gmock.h>
++#include <gtest/gtest.h>
++
++#include <linux/input.h>
++
++#include <boost/throw_exception.hpp>
++#include <atomic>
++
++using namespace std::chrono_literals;
++using namespace mir::geometry;
++using namespace testing;
++using mir::test::Signal;
++
++namespace
++{
++class Cookie
++{
++public:
++    Cookie() = default;
++    explicit Cookie(MirCookie const* cookie) : self{cookie, deleter} {}
++
++    operator MirCookie const*() const { return self.get(); }
++    auto get() const -> MirCookie const* { return self.get(); }
++
++    void reset() { self.reset(); }
++    void reset(MirCookie const* cookie) { self.reset(cookie, deleter); }
++
++private:
++    static void deleter(MirCookie const* cookie) { mir_cookie_release(cookie); }
++    std::shared_ptr<MirCookie const> self;
++};
++
++void mir_cookie_release(Cookie const&) = delete;
++
++class Blob
++{
++public:
++    Blob() = default;
++    explicit Blob(MirBlob* blob) : self{blob, deleter} {}
++
++    operator MirBlob*() const { return self.get(); }
++    auto get() const -> MirBlob* { return self.get(); }
++
++    void reset() { self.reset(); }
++    void reset(MirBlob* blob) { self.reset(blob, deleter); }
++
++private:
++    static void deleter(MirBlob* blob) { mir_blob_release(blob); }
++    std::shared_ptr<MirBlob> self;
++};
++
++void mir_blob_release(Blob const&) = delete;
++
++struct MouseMoverAndFaker
++{
++    void start_dragging_mouse()
++    {
++        using namespace mir::input::synthesis;
++        fake_mouse->emit_event(a_button_down_event().of_button(BTN_LEFT));
++    }
++
++    void move_mouse(Displacement const& displacement)
++    {
++        using mir::input::synthesis::a_pointer_event;
++        fake_mouse->emit_event(a_pointer_event().with_movement(displacement.dx.as_int(), displacement.dy.as_int()));
++    }
++
++    void release_mouse()
++    {
++        using namespace mir::input::synthesis;
++        fake_mouse->emit_event(a_button_up_event().of_button(BTN_LEFT));
++    }
++
++private:
++    std::unique_ptr<mir_test_framework::FakeInputDevice> fake_mouse{
++        mir_test_framework::add_fake_input_device(
++            mir::input::InputDeviceInfo{"mouse", "mouse-uid", mir::input::DeviceCapability::pointer})};
++};
++
++Rectangle const screen_geometry{{0,0}, {800,600}};
++auto const receive_event_timeout = 90s;
++
++struct DragAndDrop : mir_test_framework::ConnectedClientWithAWindow,
++                     MouseMoverAndFaker
++{
++    MirDragAndDropV1 const* dnd = nullptr;
++
++    void SetUp() override
++    {
++        initial_display_layout({screen_geometry});
++        mir_test_framework::ConnectedClientWithAWindow::SetUp();
++        dnd = mir_drag_and_drop_v1(connection);
++        mir_window_set_event_handler(window, &window_event_handler, this);
++        if (dnd) dnd->set_start_drag_and_drop_callback(window, &window_dnd_start_handler, this);
++
++        create_target_window();
++
++        paint_window(window);
++
++        center_mouse();
++    }
++
++    void TearDown() override
++    {
++        reset_window_event_handler(target_window);
++        reset_window_event_handler(window);
++        mir_window_release_sync(target_window);
++        mir_connection_release(another_connection);
++        mir_test_framework::ConnectedClientWithAWindow::TearDown();
++    }
++
++    auto user_initiates_drag() -> Cookie;
++    auto client_requests_drag(Cookie const& cookie) -> Blob;
++    auto handle_from_mouse_move() -> Blob;
++    auto handle_from_mouse_leave() -> Blob;
++    auto handle_from_mouse_enter() -> Blob;
++    auto handle_from_mouse_release() -> Blob;
++    auto count_of_handles_when_moving_mouse() -> int;
++
++private:
++    void center_mouse();
++    void paint_window(MirWindow* w);
++    void set_window_event_handler(MirWindow* window, std::function<void(MirEvent const* event)> const& handler);
++    void set_window_dnd_start_handler(MirWindow* window, std::function<void(MirDragAndDropEvent const*)> const& handler);
++    void reset_window_event_handler(MirWindow* window);
++
++    void create_target_window()
++    {
++        another_connection = mir_connect_sync(new_connection().c_str(), "another_connection");
++        auto const spec = mir_create_normal_window_spec(
++            connection, screen_geometry.size.width.as_int(), screen_geometry.size.height.as_int());
++        mir_window_spec_set_pixel_format(spec, mir_pixel_format_abgr_8888);
++        mir_window_spec_set_name(spec, "target_window");
++        mir_window_spec_set_buffer_usage(spec, mir_buffer_usage_hardware);
++        mir_window_spec_set_event_handler(spec, &window_event_handler, this);
++
++        target_window = mir_create_window_sync(spec);
++        mir_window_spec_release(spec);
++
++        paint_window(target_window);
++    }
++
++    void invoke_window_event_handler(MirWindow* window, MirEvent const* event)
++    {
++        std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
++        if (window == this->window) window_event_handler_(event);
++        if (window == target_window) target_window_event_handler_(event);
++    }
++
++    void invoke_window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event)
++    {
++        std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
++        if (window == this->window) window_dnd_start_(event);
++    }
++
++    std::mutex window_event_handler_mutex;
++    std::function<void(MirDragAndDropEvent const* event)> window_dnd_start_ = [](MirDragAndDropEvent const*) {};
++    std::function<void(MirEvent const* event)> window_event_handler_ = [](MirEvent const*) {};
++    std::function<void(MirEvent const* event)> target_window_event_handler_ = [](MirEvent const*) {};
++
++    static void window_event_handler(MirWindow* window, MirEvent const* event, void* context);
++    static void window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event, void* context);
++
++    MirConnection* another_connection{nullptr};
++    MirWindow*     target_window{nullptr};
++};
++
++void DragAndDrop::set_window_event_handler(MirWindow* window, std::function<void(MirEvent const* event)> const& handler)
++{
++    std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
++    if (window == this->window) window_event_handler_ = handler;
++    if (window == target_window) target_window_event_handler_ = handler;
++}
++
++void DragAndDrop::set_window_dnd_start_handler(MirWindow* window, std::function<void(MirDragAndDropEvent const*)> const& handler)
++{
++    std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex};
++    if (window == this->window) window_dnd_start_ = handler;
++}
++
++
++void DragAndDrop::reset_window_event_handler(MirWindow* window)
++{
++    if (window == this->window) window_event_handler_ = [](MirEvent const*) {};
++    if (window == target_window) target_window_event_handler_ = [](MirEvent const*) {};
++}
++
++void DragAndDrop::paint_window(MirWindow* w)
++{
++    Signal have_focus;
++
++    set_window_event_handler(w, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_window)
++                return;
++
++            auto const window_event = mir_event_get_window_event(event);
++            if (mir_window_event_get_attribute(window_event) != mir_window_attrib_focus)
++                return;
++
++            if (mir_window_event_get_attribute_value(window_event))
++                have_focus.raise();
++        });
++
++    mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(w));
++
++    EXPECT_THAT(have_focus.wait_for(receive_event_timeout), Eq(true));
++
++    reset_window_event_handler(w);
++}
++
++void DragAndDrop::center_mouse()
++{
++    Signal have_mouseover;
++
++    set_window_event_handler(window, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter)
++                return;
++
++            have_mouseover.raise();
++        });
++
++    move_mouse(0.5 * as_displacement(screen_geometry.size));
++
++// We miss the "mouseover" occasionally (with valgrind and heavy stress about 1/20).
++// But it isn't essential for the test and we've probably waited long enough
++// for the mouse-down needed by the test to reach the window.
++//    EXPECT_THAT(have_mouseover.wait_for(receive_event_timeout), Eq(true));
++    have_mouseover.wait_for(receive_event_timeout);
++
++    reset_window_event_handler(window);
++}
++
++void DragAndDrop::window_event_handler(MirWindow* window, MirEvent const* event, void* context)
++{
++    static_cast<DragAndDrop*>(context)->invoke_window_event_handler(window, event);
++}
++
++void DragAndDrop::window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event, void* context)
++{
++    static_cast<DragAndDrop*>(context)->invoke_window_dnd_start_handler(window, event);
++}
++
++
++auto DragAndDrop::user_initiates_drag() -> Cookie
++{
++    Cookie cookie;
++    Signal have_cookie;
++
++    set_window_event_handler(window, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_down)
++                return;
++
++            cookie = Cookie{mir_input_event_get_cookie(input_event)};
++            have_cookie.raise();
++        });
++
++    start_dragging_mouse();
++
++    EXPECT_THAT(have_cookie.wait_for(receive_event_timeout), Eq(true));
++
++    reset_window_event_handler(window);
++    return cookie;
++}
++
++auto DragAndDrop::client_requests_drag(Cookie const& cookie) -> Blob
++{
++    Blob blob;
++    Signal initiated;
++
++    set_window_dnd_start_handler(window, [&](MirDragAndDropEvent const* event)
++        {
++            if (dnd)
++                blob.reset(dnd->start_drag_and_drop(event));
++
++            if (blob)
++                initiated.raise();
++        });
++
++    EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
++
++    if (dnd)
++        dnd->request_drag_and_drop(window, cookie);
++
++    EXPECT_TRUE(initiated.wait_for(receive_event_timeout));
++
++    reset_window_event_handler(window);
++    return blob;
++}
++
++auto DragAndDrop::handle_from_mouse_move() -> Blob
++{
++    Blob blob;
++    Signal have_blob;
++
++    set_window_event_handler(window, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
++
++            if (dnd)
++                blob.reset(dnd->pointer_drag_and_drop(pointer_event));
++
++            if (blob)
++                have_blob.raise();
++        });
++
++    move_mouse({1,1});
++
++    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
++
++    reset_window_event_handler(window);
++    return blob;
++}
++
++auto DragAndDrop::handle_from_mouse_leave() -> Blob
++{
++    Blob blob;
++    Signal have_blob;
++
++    set_window_event_handler(window, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_leave)
++                return;
++
++            EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
++
++            if (dnd)
++                blob.reset(dnd->pointer_drag_and_drop(pointer_event));
++
++            if (blob)
++                have_blob.raise();
++        });
++
++    move_mouse({1,1});
++    move_mouse(0.5 * as_displacement(surface_size));
++
++    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
++
++    reset_window_event_handler(window);
++    return blob;
++}
++
++auto DragAndDrop::handle_from_mouse_enter() -> Blob
++{
++    Blob blob;
++    Signal have_blob;
++
++    set_window_event_handler(target_window, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter)
++                return;
++
++            EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
++
++            if (dnd)
++                blob.reset(dnd->pointer_drag_and_drop(pointer_event));
++
++            if (blob)
++                have_blob.raise();
++        });
++
++    move_mouse({1,1});
++    move_mouse(0.5 * as_displacement(surface_size));
++
++    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
++
++    reset_window_event_handler(target_window);
++    return blob;
++}
++
++auto DragAndDrop::handle_from_mouse_release() -> Blob
++{
++    Blob blob;
++    Signal have_blob;
++
++    set_window_event_handler(target_window, [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_up)
++                return;
++
++            EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
++
++            if (dnd)
++                blob.reset(dnd->pointer_drag_and_drop(pointer_event));
++
++            if (blob)
++                have_blob.raise();
++        });
++
++    move_mouse({1,1});
++    move_mouse(0.5 * as_displacement(surface_size));
++    release_mouse();
++
++    EXPECT_TRUE(have_blob.wait_for(receive_event_timeout));
++
++    reset_window_event_handler(target_window);
++    return blob;
++}
++
++auto DragAndDrop::count_of_handles_when_moving_mouse() -> int
++{
++    Signal have_3_events;
++    std::atomic<int> events{0};
++    std::atomic<int> handles{0};
++
++    auto counter = [&](MirEvent const* event)
++        {
++            if (mir_event_get_type(event) != mir_event_type_input)
++                return;
++
++            auto const input_event = mir_event_get_input_event(event);
++
++            if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer)
++                return;
++
++            auto const pointer_event = mir_input_event_get_pointer_event(input_event);
++
++            EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension";
++
++            Blob blob;
++            if (dnd)
++                blob.reset(dnd->pointer_drag_and_drop(pointer_event));
++
++            if (blob)
++                handles.fetch_add(1);
++
++            if (events.fetch_add(1) == 2)
++                have_3_events.raise();
++        };
++
++    set_window_event_handler(window, counter);
++    set_window_event_handler(target_window, counter);
++
++    start_dragging_mouse();
++    move_mouse({1,1});
++    release_mouse();
++
++    EXPECT_TRUE(have_3_events.wait_for(receive_event_timeout));
++
++    reset_window_event_handler(window);
++    reset_window_event_handler(target_window);
++    return handles;
++}
++
++MATCHER_P(BlobContentEq, p, "")
++{
++    if (!arg || !p)
++        return false;
++    if (mir_blob_size(arg) != mir_blob_size(p))
++        return false;
++    return !memcmp(mir_blob_data(arg), mir_blob_data(p), mir_blob_size(p));
++}
++}
++
++TEST_F(DragAndDrop, when_user_initiates_drag_client_receives_cookie)
++{
++    auto const cookie = user_initiates_drag();
++
++    EXPECT_THAT(cookie.get(), NotNull());
++}
++
++TEST_F(DragAndDrop, when_client_requests_drags_it_receives_handle)
++{
++    auto const cookie = user_initiates_drag();
++    ASSERT_THAT(cookie.get(), NotNull());
++
++    auto const handle = client_requests_drag(cookie);
++
++    EXPECT_THAT(handle.get(), NotNull());
++}
++
++TEST_F(DragAndDrop, during_drag_when_user_moves_mouse_client_receives_handle)
++{
++    auto const cookie = user_initiates_drag();
++    ASSERT_THAT(cookie.get(), NotNull());
++    auto const handle_from_request = client_requests_drag(cookie);
++
++    auto const handle = handle_from_mouse_move();
++
++    EXPECT_THAT(handle.get(), NotNull());
++    EXPECT_THAT(handle.get(), BlobContentEq(handle_from_request.get()));
++}
++
++TEST_F(DragAndDrop, when_drag_moves_from_window_leave_event_contains_handle)
++{
++    auto const cookie = user_initiates_drag();
++    ASSERT_THAT(cookie.get(), NotNull());
++    auto const handle_from_request = client_requests_drag(cookie);
++
++    auto const handle = handle_from_mouse_leave();
++
++    EXPECT_THAT(handle.get(), NotNull());
++    EXPECT_THAT(handle.get(), BlobContentEq(handle_from_request.get()));
++}
++
++TEST_F(DragAndDrop, when_drag_enters_target_window_enter_event_contains_handle)
++{
++    auto const cookie = user_initiates_drag();
++    ASSERT_THAT(cookie.get(), NotNull());
++    auto const handle_from_request = client_requests_drag(cookie);
++
++    auto const handle = handle_from_mouse_enter();
++
++    EXPECT_THAT(handle.get(), NotNull());
++    EXPECT_THAT(handle.get(), BlobContentEq(handle_from_request.get()));
++}
++
++TEST_F(DragAndDrop, when_drag_releases_target_window_release_event_contains_handle)
++{
++    auto const cookie = user_initiates_drag();
++    ASSERT_THAT(cookie.get(), NotNull());
++    auto const handle_from_request = client_requests_drag(cookie);
++
++    auto const handle = handle_from_mouse_release();
++
++    EXPECT_THAT(handle.get(), NotNull());
++    EXPECT_THAT(handle.get(), BlobContentEq(handle_from_request.get()));
++}
++
++TEST_F(DragAndDrop, after_drag_finishes_pointer_events_no_longer_contain_handle)
++{
++    auto const cookie = user_initiates_drag();
++    ASSERT_THAT(cookie.get(), NotNull());
++    client_requests_drag(cookie);
++    handle_from_mouse_release();
++
++    server.the_shell()->clear_drag_and_drop_handle();
++
++    EXPECT_THAT(count_of_handles_when_moving_mouse(), Eq(0));
++}
 === modified file 'tests/acceptance-tests/test_client_cursor_api.cpp'
 --- tests/acceptance-tests/test_client_cursor_api.cpp	2017-02-28 08:53:57 +0000
 +++ tests/acceptance-tests/test_client_cursor_api.cpp	2017-03-17 15:49:43 +0000
@@ -82,6 +82,7 @@
      MOCK_METHOD0(cursor_image_removed, void());
      MOCK_METHOD1(placed_relative, void(geom::Rectangle const& placement));
      MOCK_METHOD1(input_consumed, void(MirEvent const*));
++    MOCK_METHOD1(start_drag_and_drop, void(std::vector<uint8_t> const& handle));
  };
 === modified file 'tests/include/mir/test/doubles/mock_input_targeter.h'
 --- tests/include/mir/test/doubles/mock_input_targeter.h	2015-06-18 02:46:16 +0000
 +++ tests/include/mir/test/doubles/mock_input_targeter.h	2017-03-17 15:49:43 +0000
@@ -35,6 +35,9 @@
      virtual ~MockInputTargeter() noexcept(true) {}
      MOCK_METHOD1(set_focus, void(std::shared_ptr<input::Surface> const&));
      MOCK_METHOD0(clear_focus, void());
++
++    void set_drag_and_drop_handle(std::vector<uint8_t> const&) override {}
++    void clear_drag_and_drop_handle() override {}
  };
+ }
 === modified file 'tests/include/mir/test/doubles/mock_shell.h'
 --- tests/include/mir/test/doubles/mock_shell.h	2017-01-18 02:29:37 +0000
 +++ tests/include/mir/test/doubles/mock_shell.h	2017-03-17 15:49:43 +0000
@@ -72,6 +72,9 @@
      MOCK_METHOD3(raise_surface, void(std::shared_ptr<frontend::Session> const& session,
          frontend::SurfaceId surface_id, uint64_t timestamp));
++
++    MOCK_METHOD3(request_drag_and_drop, void(std::shared_ptr<frontend::Session> const& session,
++        frontend::SurfaceId surface_id, uint64_t timestamp));
  };
+ }
 === modified file 'tests/include/mir/test/doubles/stub_display_server.h'
 --- tests/include/mir/test/doubles/stub_display_server.h	2017-02-15 07:38:33 +0000
 +++ tests/include/mir/test/doubles/stub_display_server.h	2017-03-17 15:49:43 +0000
@@ -158,6 +158,10 @@
          mir::protobuf::RaiseRequest const* /*request*/,
          mir::protobuf::Void* /*response*/,
          google::protobuf::Closure* /*done*/) {}
++    void request_drag_and_drop(
++        mir::protobuf::RequestAuthority const* /*request*/,
++        mir::protobuf::Void* /*response*/,
++        google::protobuf::Closure* /*done*/) {}
      void apply_input_configuration(
          mir::protobuf::InputConfigurationRequest const* /*request*/,
          mir::protobuf::Void* /*response*/,
 === modified file 'tests/include/mir/test/doubles/stub_input_targeter.h'
 --- tests/include/mir/test/doubles/stub_input_targeter.h	2015-06-18 02:46:16 +0000
 +++ tests/include/mir/test/doubles/stub_input_targeter.h	2017-03-17 15:49:43 +0000
@@ -36,6 +36,9 @@
      void clear_focus()
+     {
+     }
++
++    void set_drag_and_drop_handle(std::vector<uint8_t> const&) override {}
++    void clear_drag_and_drop_handle() override {}
  };
+ }
 === modified file 'tests/include/mir/test/doubles/stub_scene_surface.h'
 --- tests/include/mir/test/doubles/stub_scene_surface.h	2017-02-15 14:45:41 +0000
 +++ tests/include/mir/test/doubles/stub_scene_surface.h	2017-03-17 15:49:43 +0000
@@ -94,6 +94,7 @@
      void set_confine_pointer_state(MirPointerConfinementState /*state*/) override {}
      MirPointerConfinementState confine_pointer_state() const override { return {}; }
      void placed_relative(geometry::Rectangle const& /*placement*/) override {}
++    void start_drag_and_drop(std::vector<uint8_t> const& /*handle*/) override {}
  };
+ }
 === modified file 'tests/mir_test_framework/observant_shell.cpp'
 --- tests/mir_test_framework/observant_shell.cpp	2017-01-20 00:01:50 +0000
 +++ tests/mir_test_framework/observant_shell.cpp	2017-03-17 15:49:43 +0000
@@ -155,7 +155,26 @@
  void mtf::ObservantShell::raise_surface(
      std::shared_ptr<msc::Session> const& session,
      std::shared_ptr<msc::Surface> const& window,
++    uint64_t timestamp)
++{
++    return wrapped->raise_surface(session, window, timestamp);
++}
++
++void mtf::ObservantShell::request_drag_and_drop(
++    std::shared_ptr<msc::Session> const& session,
++    std::shared_ptr<msc::Surface> const& window,
      uint64_t timestamp)
+ {
--    return wrapped->raise_surface(session, window, timestamp);
--}
++    return wrapped->request_drag_and_drop(session, window, timestamp);
++}
++
++void mtf::ObservantShell::set_drag_and_drop_handle(std::vector<uint8_t> const& handle)
++{
++    wrapped->set_drag_and_drop_handle(handle);
++}
++
++void mtf::ObservantShell::clear_drag_and_drop_handle()
++{
++    wrapped->clear_drag_and_drop_handle();
++}
++
 === modified file 'tests/mir_test_framework/stub_surface.cpp'
 --- tests/mir_test_framework/stub_surface.cpp	2017-02-15 14:45:41 +0000
 +++ tests/mir_test_framework/stub_surface.cpp	2017-03-17 15:49:43 +0000
@@ -198,6 +198,10 @@
+ {
+ }
++void mtd::StubSurface::start_drag_and_drop(std::vector<uint8_t> const& /*handle*/)
++{
++}
++
  namespace
+ {
  // Ensure we don't accidentally have an abstract class