Merge lp:~ken-vandine/gtk/ubuntugtk3 into lp:~ubuntu-desktop/gtk/ubuntugtk3

[Ken VanDine]

Re-enable the mir backend, however removed the content-hub related code and depends.

Re-enable the mir backend, however removed the content-hub related code and depends.

[Sebastien Bacher (seb128)]

the changes look good, thanks Ken

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2017-05-22 14:18:53 +0000
+++ debian/changelog	2017-06-06 19:53:49 +0000
@@ -3,6 +3,13 @@
   * debian/control.in
     - Bumped libpango1.0-dev build depends to >= 1.40.5 needed for 
       colornames test
+    - Added build depends needed for the mir backend
+  * debian/rules
+    - re-enable mir backend
+  * debian/libgtk-3-0.symbols
+    - Refreshed
+  * patches/no_content_hub.patch
+    - Removed content-hub related code
 
  -- Ken VanDine <[e-mail]>  Mon, 22 May 2017 10:16:57 -0400
 

=== modified file 'debian/control'
--- debian/control	2017-05-11 16:35:56 +0000
+++ debian/control	2017-06-06 19:53:49 +0000
@@ -3,7 +3,7 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 XSBC-Original-Maintainer: Debian GNOME Maintainers <[e-mail]>
-Uploaders: Andreas Henriksson <[e-mail]>, Debian GNOME Maintainers <[e-mail]>, Jeremy Bicha <[e-mail]>, Michael Biebl <[e-mail]>
+Uploaders: Debian GNOME Maintainers <[e-mail]>, Jeremy Bicha <[e-mail]>, Michael Biebl <[e-mail]>
 Build-Depends: debhelper (>= 9.20141010),
                cdbs (>= 0.4.93),
                gnome-pkg-tools (>= 0.11),
@@ -51,6 +51,8 @@
                xauth <!nocheck>,
                xsltproc,
                xvfb <!nocheck>,
+               libmirclient-dev (>= 0.13.3),
+               libmircookie-dev (>= 0.17.0),
 Build-Depends-Indep: libglib2.0-doc,
                      libatk1.0-doc,
                      libpango1.0-doc,
@@ -148,6 +150,8 @@
          ${shlibs:Depends},
          libglib2.0-dev (>= 2.49.4),
          libgdk-pixbuf2.0-dev (>= 2.30.0),
+         libmirclient-dev (>= 0.13.3),
+         libmircookie-dev (>= 0.17.0),
          libpango1.0-dev (>= 1.37.3),
          libatk1.0-dev (>= 2.15.1),
          libatk-bridge2.0-dev,

=== modified file 'debian/control.in'
--- debian/control.in	2017-05-22 14:18:53 +0000
+++ debian/control.in	2017-06-06 19:53:49 +0000
@@ -51,6 +51,8 @@
                xauth <!nocheck>,
                xsltproc,
                xvfb <!nocheck>,
+               libmirclient-dev (>= 0.13.3),
+               libmircookie-dev (>= 0.17.0),
 Build-Depends-Indep: libglib2.0-doc,
                      libatk1.0-doc,
                      libpango1.0-doc,
@@ -148,6 +150,8 @@
          ${shlibs:Depends},
          libglib2.0-dev (>= 2.49.4),
          libgdk-pixbuf2.0-dev (>= 2.30.0),
+         libmirclient-dev (>= 0.13.3),
+         libmircookie-dev (>= 0.17.0),
          libpango1.0-dev (>= 1.40.5),
          libatk1.0-dev (>= 2.15.1),
          libatk-bridge2.0-dev,

=== modified file 'debian/libgtk-3-0.symbols'
--- debian/libgtk-3-0.symbols	2017-05-11 19:42:33 +0000
+++ debian/libgtk-3-0.symbols	2017-06-06 19:53:49 +0000
@@ -328,6 +328,11 @@
  gdk_keyval_to_unicode@Base 3.0.0
  gdk_keyval_to_upper@Base 3.0.0
  gdk_list_visuals@Base 3.0.0
+ gdk_mir_display_get_mir_connection@Base 3.12.2-0ubuntu5
+ gdk_mir_display_get_type@Base 3.12.2-0ubuntu5
+ gdk_mir_gl_context_get_type@Base 3.16.2
+ gdk_mir_window_get_mir_surface@Base 3.16.2
+ gdk_mir_window_get_type@Base 3.12.2-0ubuntu5
  gdk_modifier_intent_get_type@Base 3.3.16
  gdk_modifier_type_get_type@Base 3.0.0
  gdk_monitor_get_display@Base 3.21.4

=== added file 'debian/patches/0001-Update-the-GDK-Mir-backend-to-fix-a-few-problems.patch'
--- debian/patches/0001-Update-the-GDK-Mir-backend-to-fix-a-few-problems.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0001-Update-the-GDK-Mir-backend-to-fix-a-few-problems.patch	2017-06-06 19:53:49 +0000
@@ -0,0 +1,905 @@
+From 52b9d12764e90efe21806a54c4191ae999ed7751 Mon Sep 17 00:00:00 2001
+From: Andreas Pokorny <[e-mail]>
+Date: Tue, 19 Jul 2016 14:56:34 +0200
+Subject: [PATCH] Update the GDK-Mir backend to fix a few problems
+
+See https://bugzilla.gnome.org/show_bug.cgi?id=768138
+---
+ configure.ac                |   2 +-
+ gdk/mir/gdkmir-private.h    |   4 +-
+ gdk/mir/gdkmirdisplay.c     |   2 +-
+ gdk/mir/gdkmireventsource.c |  62 +++----
+ gdk/mir/gdkmirscreen.c      |   4 +-
+ gdk/mir/gdkmirwindowimpl.c  | 425 ++++++++++++++++++++++++++++++++++++--------
+ 6 files changed, 382 insertions(+), 117 deletions(-)
+
+diff --git a/configure.ac b/configure.ac
+index 89722cd..66a5fc6 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -61,7 +61,7 @@ m4_define([gdk_pixbuf_required_version], [2.30.0])
+ m4_define([introspection_required_version], [1.39.0])
+ m4_define([wayland_required_version], [1.9.91])
+ m4_define([wayland_protocols_required_version], [1.0])
+-m4_define([mirclient_required_version], [0.11.0])
++m4_define([mirclient_required_version], [0.22.0])
+ m4_define([mircookie_required_version], [0.17.0])
+ m4_define([epoxy_required_version], [1.0])
+ GLIB_REQUIRED_VERSION=glib_required_version
+diff --git a/gdk/mir/gdkmir-private.h b/gdk/mir/gdkmir-private.h
+index 84051a7..38f1d7a 100644
+--- a/gdk/mir/gdkmir-private.h
++++ b/gdk/mir/gdkmir-private.h
+@@ -83,12 +83,14 @@ GdkCursor *_gdk_mir_cursor_new_for_name (GdkDisplay *display, const gchar *name)
+ 
+ const gchar *_gdk_mir_cursor_get_name (GdkCursor *cursor);
+ 
+-GdkWindowImpl *_gdk_mir_window_impl_new (void);
++GdkWindowImpl *_gdk_mir_window_impl_new (GdkDisplay *display, GdkWindow *window, GdkWindowAttr *attributes, gint attributes_mask);
+ 
+ void _gdk_mir_window_impl_set_surface_state (GdkMirWindowImpl *impl, MirSurfaceState state);
+ 
+ void _gdk_mir_window_impl_set_surface_type (GdkMirWindowImpl *impl, MirSurfaceType type);
+ 
++void _gdk_mir_window_set_surface_output (GdkWindow *window, gdouble scale);
++
+ void _gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl, gdouble x, gdouble y, gboolean cursor_inside, guint button_state);
+ 
+ void _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl, gdouble *x, gdouble *y, gboolean *cursor_inside, guint *button_state);
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index ffcee8a..eea892c 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -411,7 +411,7 @@ gdk_mir_display_create_window_impl (GdkDisplay    *display,
+ 
+   if (attributes->wclass == GDK_INPUT_OUTPUT)
+     {
+-      window->impl = _gdk_mir_window_impl_new ();
++      window->impl = _gdk_mir_window_impl_new (display, window, attributes, attributes_mask);
+       window->impl_window = window;
+     }
+   else /* attributes->wclass == GDK_INPUT_ONLY */
+diff --git a/gdk/mir/gdkmireventsource.c b/gdk/mir/gdkmireventsource.c
+index a288cb7..865b6f6 100644
+--- a/gdk/mir/gdkmireventsource.c
++++ b/gdk/mir/gdkmireventsource.c
+@@ -289,28 +289,17 @@ handle_key_event (GdkWindow *window, const MirInputEvent *event)
+   if (!keyboard_event)
+     return;
+ 
+-  switch (mir_keyboard_event_action (keyboard_event))
+-    {
+-    case mir_keyboard_action_up:
+-    case mir_keyboard_action_down:
+-      // FIXME: Convert keycode
+-      _gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, NULL, &button_state);
+-      modifier_state = get_modifier_state (mir_keyboard_event_modifiers (keyboard_event), button_state);
+-      keymap = gdk_keymap_get_for_display (gdk_window_get_display (window));
+-
+-      generate_key_event (window,
+-                          mir_keyboard_event_action (keyboard_event) == mir_keyboard_action_down ? GDK_KEY_PRESS : GDK_KEY_RELEASE,
+-                          modifier_state,
+-                          mir_keyboard_event_key_code (keyboard_event),
+-                          mir_keyboard_event_scan_code (keyboard_event),
+-                          _gdk_mir_keymap_key_is_modifier (keymap, mir_keyboard_event_key_code (keyboard_event)),
+-                          NANO_TO_MILLI (mir_input_event_get_event_time (event)));
+-      break;
+-    default:
+-    //case mir_key_action_multiple:
+-      // FIXME
+-      break;
+-    }
++  _gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, NULL, &button_state);
++  modifier_state = get_modifier_state (mir_keyboard_event_modifiers (keyboard_event), button_state);
++  keymap = gdk_keymap_get_for_display (gdk_window_get_display (window));
++
++  generate_key_event (window,
++                      mir_keyboard_event_action (keyboard_event) == mir_keyboard_action_up ? GDK_KEY_RELEASE : GDK_KEY_PRESS,
++                      modifier_state,
++                      mir_keyboard_event_key_code (keyboard_event),
++                      mir_keyboard_event_scan_code (keyboard_event),
++                      _gdk_mir_keymap_key_is_modifier (keymap, mir_keyboard_event_key_code (keyboard_event)),
++                      NANO_TO_MILLI (mir_input_event_get_event_time (event)));
+ }
+ 
+ static void
+@@ -324,18 +313,13 @@ handle_touch_event (GdkWindow           *window,
+ 
+   for (i = 0; i < n; i++)
+     {
+-      switch (mir_touch_event_action (mir_touch_event, i))
+-        {
+-        case mir_touch_action_up:
+-          gdk_event = gdk_event_new (GDK_TOUCH_END);
+-          break;
+-        case mir_touch_action_down:
+-          gdk_event = gdk_event_new (GDK_TOUCH_BEGIN);
+-          break;
+-        case mir_touch_action_change:
+-          gdk_event = gdk_event_new (GDK_TOUCH_UPDATE);
+-          break;
+-        }
++      MirTouchAction action = mir_touch_event_action (mir_touch_event, i);
++      if (action == mir_touch_action_up)
++        gdk_event = gdk_event_new (GDK_TOUCH_END);
++      else if (action == mir_touch_action_down)
++        gdk_event = gdk_event_new (GDK_TOUCH_BEGIN);
++      else
++        gdk_event = gdk_event_new (GDK_TOUCH_UPDATE);
+ 
+       gdk_event->touch.window = window;
+       gdk_event->touch.sequence = GINT_TO_POINTER (mir_touch_event_id (mir_touch_event, i));
+@@ -543,6 +527,13 @@ handle_close_event (GdkWindow *window)
+   gdk_window_destroy_notify (window);
+ }
+ 
++static void
++handle_surface_output_event (GdkWindow                  *window,
++                             const MirSurfaceOutputEvent *event)
++{
++  _gdk_mir_window_set_surface_output (window, mir_surface_output_event_get_scale (event));
++}
++
+ typedef struct
+ {
+   GdkWindow *window;
+@@ -597,6 +588,9 @@ gdk_mir_event_source_queue_event (GdkDisplay     *display,
+     case mir_event_type_close_surface:
+       handle_close_event (window);
+       break;
++    case mir_event_type_surface_output:
++      handle_surface_output_event (window, mir_event_get_surface_output_event (event));
++      break;
+     default:
+       g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event));
+       // FIXME?
+diff --git a/gdk/mir/gdkmirscreen.c b/gdk/mir/gdkmirscreen.c
+index 7aa0aa6..b369b03 100644
+--- a/gdk/mir/gdkmirscreen.c
++++ b/gdk/mir/gdkmirscreen.c
+@@ -257,7 +257,6 @@ gdk_mir_screen_get_root_window (GdkScreen *screen)
+   get_screen_size (GDK_MIR_SCREEN (screen)->display_config, &width, &height);
+ 
+   s->root_window = _gdk_display_create_window (s->display);
+-  s->root_window->impl = _gdk_mir_window_impl_new ();
+   s->root_window->impl_window = s->root_window;
+   s->root_window->visual = s->visual;
+   s->root_window->window_type = GDK_WINDOW_ROOT;
+@@ -269,6 +268,7 @@ gdk_mir_screen_get_root_window (GdkScreen *screen)
+   s->root_window->width = width;
+   s->root_window->height = height;
+   s->root_window->viewable = TRUE;
++  s->root_window->impl = _gdk_mir_window_impl_new (s->display, s->root_window, NULL, 0);
+ 
+   return s->root_window;
+ }
+@@ -352,6 +352,8 @@ gdk_mir_screen_get_monitor_plug_name (GdkScreen *screen,
+             return g_strdup_printf ("TV-%u", output->output_id);
+           case mir_display_output_type_edp:
+             return g_strdup_printf ("eDP-%u", output->output_id);
++          case mir_display_output_type_virtual:
++            return g_strdup_printf ("Virtual-%u", output->output_id);
+         }
+     }
+ 
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index 5ca9d89..fc37c7e 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -16,6 +16,7 @@
+  */
+ 
+ #include <inttypes.h>
++#include <math.h>
+ 
+ #include "config.h"
+ 
+@@ -28,6 +29,7 @@
+ #include "gdkintl.h"
+ #include "gdkdisplayprivate.h"
+ #include "gdkdeviceprivate.h"
++#include "gdkframeclockprivate.h"
+ 
+ #define GDK_MIR_WINDOW_IMPL_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_MIR, GdkMirWindowImplClass))
+ #define GDK_IS_WINDOW_IMPL_MIR_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_MIR))
+@@ -58,12 +60,21 @@ struct _GdkMirWindowImpl
+   gdouble y;
+   guint button_state;
+ 
++  GdkDisplay *display;
++
+   /* Surface being rendered to (only exists when window visible) */
+   MirSurface *surface;
++  MirBufferStream *buffer_stream;
++  MirBufferUsage buffer_usage;
+ 
+   /* Cairo context for current frame */
+   cairo_surface_t *cairo_surface;
+ 
++  gchar *title;
++
++  GdkGeometry geometry_hints;
++  GdkWindowHints geometry_mask;
++
+   /* Egl surface for the current mir surface */
+   EGLSurface egl_surface;
+ 
+@@ -75,6 +86,12 @@ struct _GdkMirWindowImpl
+ 
+   /* TRUE if cursor is inside this window */
+   gboolean cursor_inside;
++
++  gboolean pending_redraw;
++  gboolean pending_commit;
++  gboolean pending_swap;
++  gboolean pending_spec_update;
++  gint output_scale;
+ };
+ 
+ struct _GdkMirWindowImplClass
+@@ -85,11 +102,97 @@ struct _GdkMirWindowImplClass
+ G_DEFINE_TYPE (GdkMirWindowImpl, gdk_mir_window_impl, GDK_TYPE_WINDOW_IMPL)
+ 
+ static cairo_surface_t *gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window);
++static void on_frame_clock_after_paint (GdkFrameClock *clock, GdkWindow *window);
++static void ensure_surface (GdkWindow *window);
++static void apply_geometry_hints (MirSurfaceSpec *spec, GdkMirWindowImpl *impl);
++
++static gboolean
++type_hint_differs (GdkWindowTypeHint lhs, GdkWindowTypeHint rhs)
++{
++    if (lhs == rhs)
++      return FALSE;
++
++    switch (lhs)
++    {
++      case GDK_WINDOW_TYPE_HINT_DIALOG:
++      case GDK_WINDOW_TYPE_HINT_DOCK:
++        return rhs != GDK_WINDOW_TYPE_HINT_DIALOG &&
++            rhs != GDK_WINDOW_TYPE_HINT_DOCK;
++      case GDK_WINDOW_TYPE_HINT_MENU:
++      case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
++      case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
++      case GDK_WINDOW_TYPE_HINT_TOOLBAR:
++      case GDK_WINDOW_TYPE_HINT_COMBO:
++        return rhs != GDK_WINDOW_TYPE_HINT_MENU &&
++            rhs != GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU &&
++            rhs != GDK_WINDOW_TYPE_HINT_POPUP_MENU &&
++            rhs != GDK_WINDOW_TYPE_HINT_TOOLBAR &&
++            rhs != GDK_WINDOW_TYPE_HINT_COMBO;
++      case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
++      case GDK_WINDOW_TYPE_HINT_UTILITY:
++        return rhs != GDK_WINDOW_TYPE_HINT_SPLASHSCREEN &&
++            rhs != GDK_WINDOW_TYPE_HINT_UTILITY;
++      case GDK_WINDOW_TYPE_HINT_DND:
++      case GDK_WINDOW_TYPE_HINT_TOOLTIP:
++      case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
++        return rhs != GDK_WINDOW_TYPE_HINT_DND &&
++            rhs != GDK_WINDOW_TYPE_HINT_TOOLTIP &&
++            rhs != GDK_WINDOW_TYPE_HINT_NOTIFICATION;
++      case GDK_WINDOW_TYPE_HINT_NORMAL:
++      case GDK_WINDOW_TYPE_HINT_DESKTOP:
++      default:
++        return rhs != GDK_WINDOW_TYPE_HINT_NORMAL &&
++            rhs != GDK_WINDOW_TYPE_HINT_DESKTOP;
++    }
++}
++
++static void
++drop_cairo_surface (GdkWindow *window)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++
++  g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
++}
++
++static const gchar *
++get_default_title (void)
++{
++  const char *title;
++
++  title = g_get_application_name ();
++  if (!title)
++    title = g_get_prgname ();
++  if (!title)
++    title = "";
++
++  return title;
++}
+ 
+ GdkWindowImpl *
+-_gdk_mir_window_impl_new (void)
++_gdk_mir_window_impl_new (GdkDisplay *display, GdkWindow *window, GdkWindowAttr *attributes, gint attributes_mask)
+ {
+-  return g_object_new (GDK_TYPE_MIR_WINDOW_IMPL, NULL);
++  GdkFrameClock *frame_clock = gdk_window_get_frame_clock (window);
++  GdkMirWindowImpl *impl = g_object_new (GDK_TYPE_MIR_WINDOW_IMPL, NULL);
++
++  impl->display = display;
++
++  if (attributes && attributes_mask & GDK_WA_TITLE)
++    impl->title = g_strdup (attributes->title);
++  else
++    impl->title = g_strdup (get_default_title ());
++
++  if (attributes && attributes_mask & GDK_WA_TYPE_HINT)
++    impl->type_hint = attributes->type_hint;
++
++  impl->pending_spec_update = TRUE;
++
++  if (window->window_type != GDK_WINDOW_ROOT)
++    {
++      g_signal_connect (frame_clock, "after-paint",
++                        G_CALLBACK (on_frame_clock_after_paint), window);
++    }
++
++  return (GdkWindowImpl *) impl;
+ }
+ 
+ void
+@@ -139,18 +242,25 @@ gdk_mir_window_impl_init (GdkMirWindowImpl *impl)
+ {
+   impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
+   impl->surface_state = mir_surface_state_unknown;
++  impl->output_scale = 1;
+ }
+ 
+ static void
+ set_surface_state (GdkMirWindowImpl *impl,
+                    MirSurfaceState state)
+ {
++  MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
+   if (impl->surface_state == state)
+     return;
+ 
+   impl->surface_state = state;
+-  if (impl->surface)
+-    mir_surface_set_state (impl->surface, state);
++  if (impl->surface && !impl->pending_spec_update)
++    {
++      MirSurfaceSpec *spec = mir_connection_create_spec_for_changes (connection);
++      mir_surface_spec_set_state (spec, state);
++      mir_surface_apply_spec (impl->surface, spec);
++      mir_surface_spec_release (spec);
++    }
+ }
+ 
+ static void
+@@ -161,26 +271,21 @@ event_cb (MirSurface     *surface,
+   _gdk_mir_event_source_queue (context, event);
+ }
+ 
+-static void ensure_surface (GdkWindow *window);
+-
+-static MirSurface *
+-create_mir_surface (GdkDisplay *display,
+-                    GdkWindow *parent,
+-                    gint x,
+-                    gint y,
+-                    gint width,
+-                    gint height,
+-                    GdkWindowTypeHint type,
+-                    MirBufferUsage buffer_usage)
++static MirSurfaceSpec *
++create_window_type_spec (GdkDisplay *display,
++                         GdkWindow *parent,
++                         gint x,
++                         gint y,
++                         gint width,
++                         gint height,
++                         GdkWindowTypeHint type,
++                         MirBufferUsage buffer_usage)
+ {
+-  MirSurface *parent_surface = NULL;
+-  MirSurfaceSpec *spec;
+-  MirConnection *connection;
+-  MirPixelFormat format;
+-  MirSurface *surface;
+   MirRectangle rect;
++  MirPixelFormat format;
++  MirSurface *parent_surface = NULL;
++  MirConnection *connection = gdk_mir_display_get_mir_connection (display);
+ 
+-  connection = gdk_mir_display_get_mir_connection (display);
+   format = _gdk_mir_display_get_pixel_format (display, buffer_usage);
+ 
+   if (parent && parent->impl)
+@@ -206,11 +311,10 @@ create_mir_surface (GdkDisplay *display,
+     {
+       case GDK_WINDOW_TYPE_HINT_DIALOG:
+       case GDK_WINDOW_TYPE_HINT_DOCK:
+-        spec = mir_connection_create_spec_for_dialog (connection,
++        return mir_connection_create_spec_for_dialog (connection,
+                                                       width,
+                                                       height,
+                                                       format);
+-        break;
+       case GDK_WINDOW_TYPE_HINT_MENU:
+       case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
+       case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
+@@ -220,22 +324,20 @@ create_mir_surface (GdkDisplay *display,
+         rect.top = y;
+         rect.width = 1;
+         rect.height = 1;
+-        spec = mir_connection_create_spec_for_menu (connection,
++        return mir_connection_create_spec_for_menu (connection,
+                                                     width,
+                                                     height,
+                                                     format,
+                                                     parent_surface,
+                                                     &rect,
+                                                     mir_edge_attachment_any);
+-        break;
+       case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
+       case GDK_WINDOW_TYPE_HINT_UTILITY:
+-        spec = mir_connection_create_spec_for_modal_dialog (connection,
++        return mir_connection_create_spec_for_modal_dialog (connection,
+                                                             width,
+                                                             height,
+                                                             format,
+                                                             parent_surface);
+-        break;
+       case GDK_WINDOW_TYPE_HINT_DND:
+       case GDK_WINDOW_TYPE_HINT_TOOLTIP:
+       case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
+@@ -243,7 +345,7 @@ create_mir_surface (GdkDisplay *display,
+         rect.top = y;
+         rect.width = 1;
+         rect.height = 1;
+-        spec = mir_connection_create_spec_for_tooltip (connection,
++        return mir_connection_create_spec_for_tooltip (connection,
+                                                        width,
+                                                        height,
+                                                        format,
+@@ -253,19 +355,73 @@ create_mir_surface (GdkDisplay *display,
+       case GDK_WINDOW_TYPE_HINT_NORMAL:
+       case GDK_WINDOW_TYPE_HINT_DESKTOP:
+       default:
+-        spec = mir_connection_create_spec_for_normal_surface (connection,
++        return mir_connection_create_spec_for_normal_surface (connection,
+                                                               width,
+                                                               height,
+                                                               format);
+-        break;
+     }
++}
+ 
+-  mir_surface_spec_set_name (spec, g_get_prgname ());
+-  mir_surface_spec_set_buffer_usage (spec, buffer_usage);
+-  surface = mir_surface_create_sync (spec);
+-  mir_surface_spec_release (spec);
++static void
++apply_geometry_hints (MirSurfaceSpec *spec, GdkMirWindowImpl *impl)
++{
++  if (impl->geometry_mask & GDK_HINT_RESIZE_INC)
++    {
++      mir_surface_spec_set_width_increment (spec, impl->geometry_hints.width_inc);
++      mir_surface_spec_set_height_increment (spec, impl->geometry_hints.height_inc);
++    }
++  if (impl->geometry_mask & GDK_HINT_MIN_SIZE)
++    {
++      mir_surface_spec_set_min_width (spec, impl->geometry_hints.min_width);
++      mir_surface_spec_set_min_height (spec, impl->geometry_hints.min_height);
++    }
++  if (impl->geometry_mask & GDK_HINT_MAX_SIZE)
++    {
++      mir_surface_spec_set_max_width (spec, impl->geometry_hints.max_width);
++      mir_surface_spec_set_max_height (spec, impl->geometry_hints.max_height);
++    }
++  if (impl->geometry_mask & GDK_HINT_ASPECT)
++    {
++      mir_surface_spec_set_min_aspect_ratio (spec, 1000, (unsigned)(1000.0/impl->geometry_hints.min_aspect));
++      mir_surface_spec_set_max_aspect_ratio (spec, 1000, (unsigned)(1000.0/impl->geometry_hints.max_aspect));
++    }
++}
++
++static MirSurfaceSpec*
++create_spec (GdkWindow *window, GdkMirWindowImpl *impl)
++{
++  MirSurfaceSpec *spec = NULL;
++
++  spec = create_window_type_spec (impl->display,
++                                  impl->transient_for,
++                                  impl->transient_x, impl->transient_y,
++                                  window->width, window->height,
++                                  impl->type_hint,
++                                  impl->buffer_usage);
++
++  mir_surface_spec_set_name (spec, impl->title);
++  mir_surface_spec_set_buffer_usage (spec, impl->buffer_usage);
++
++  apply_geometry_hints (spec, impl);
++
++  return spec;
++}
++
++static void
++update_surface_spec (GdkWindow *window)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  MirSurfaceSpec *spec;
++
++  if (!impl->surface)
++    return;
++
++  spec = create_spec (window, impl);
+ 
+-  return surface;
++  mir_surface_apply_spec (impl->surface, spec);
++  mir_surface_spec_release (spec);
++  impl->pending_spec_update = FALSE;
++  impl->buffer_stream = mir_surface_get_buffer_stream (impl->surface);
+ }
+ 
+ static GdkDevice *
+@@ -319,20 +475,29 @@ ensure_surface_full (GdkWindow *window,
+ {
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+   GdkMirWindowReference *window_ref;
++  MirSurfaceSpec *spec;
+ 
+   if (impl->surface)
+-    return;
++    {
++      if (impl->pending_spec_update)
++        update_surface_spec(window);
++      return;
++    }
+ 
+   /* no destroy notify -- we must leak for now
+    * https://bugs.launchpad.net/mir/+bug/1324100
+    */
+   window_ref = _gdk_mir_event_source_get_window_reference (window);
++  impl->buffer_usage = buffer_usage;
++
++  spec = create_spec (window, impl);
++
++  impl->surface = mir_surface_create_sync (spec);
+ 
+-  impl->surface = create_mir_surface (gdk_window_get_display (window), impl->transient_for,
+-                                      impl->transient_x, impl->transient_y,
+-                                      window->width, window->height,
+-                                      impl->type_hint,
+-                                      buffer_usage);
++  mir_surface_spec_release(spec);
++
++  impl->pending_spec_update = FALSE;
++  impl->buffer_stream = mir_surface_get_buffer_stream (impl->surface);
+ 
+   /* FIXME: can't make an initial resize event */
+   // MirEvent *resize_event;
+@@ -356,9 +521,10 @@ ensure_surface_full (GdkWindow *window,
+ static void
+ ensure_surface (GdkWindow *window)
+ {
+-  ensure_surface_full (window, window->gl_paint_context ?
+-                                 mir_buffer_usage_hardware :
+-                                 mir_buffer_usage_software);
++  ensure_surface_full (window,
++                       window->gl_paint_context ?
++                         mir_buffer_usage_hardware :
++                         mir_buffer_usage_software);
+ }
+ 
+ static void
+@@ -390,19 +556,63 @@ ensure_no_surface (GdkWindow *window)
+         }
+     }
+ 
++  impl->pending_commit = FALSE;
++  impl->pending_swap = FALSE;
+   g_clear_pointer(&impl->surface, mir_surface_release_sync);
+ }
+ 
+ static void
+-send_buffer (GdkWindow *window)
++on_swap_buffer_completed (MirBufferStream *stream, void *data)
+ {
++  GdkWindow *window = data;
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+ 
+-  /* Send the completed buffer to Mir */
+-  mir_buffer_stream_swap_buffers_sync (mir_surface_get_buffer_stream (impl->surface));
+-
+   /* The Cairo context is no longer valid */
+   g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
++  impl->pending_swap = FALSE;
++
++  _gdk_frame_clock_thaw (gdk_window_get_frame_clock (window));
++}
++
++static void
++on_frame_clock_after_paint (GdkFrameClock *clock,
++                            GdkWindow     *window)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++
++  if (!impl->pending_commit)
++    return;
++
++  impl->pending_commit = FALSE;
++  _gdk_frame_clock_freeze (clock);
++
++  if (impl->pending_spec_update)
++    update_surface_spec (window);
++
++  impl->pending_spec_update = FALSE;
++
++  /* Send the completed buffer to Mir */
++  impl->pending_swap = TRUE;
++  mir_buffer_stream_swap_buffers (impl->buffer_stream, on_swap_buffer_completed, window);
++}
++
++static void
++send_buffer_delayed (GdkWindow *window)
++{
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++
++  if (impl->pending_swap || impl->pending_commit)
++    return;
++
++  impl->pending_commit = TRUE;
++}
++
++static void
++send_buffer (GdkWindow *window)
++{
++  send_buffer_delayed (window);
++  gdk_frame_clock_request_phase (gdk_window_get_frame_clock (window),
++                                 GDK_FRAME_CLOCK_PHASE_AFTER_PAINT);
+ }
+ 
+ static cairo_surface_t *
+@@ -421,15 +631,16 @@ gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window)
+       return impl->cairo_surface;
+     }
+ 
++  ensure_surface (window);
++
+   /* Transient windows get rendered into a buffer and copied onto their parent */
+   if (window->gl_paint_context)
+     {
+       cairo_surface = cairo_image_surface_create (pixel_format, window->width, window->height);
++      cairo_surface_set_device_scale (cairo_surface, (double) impl->output_scale, (double) impl->output_scale);
+     }
+   else if (impl->visible)
+     {
+-      ensure_surface (window);
+-
+       mir_buffer_stream_get_graphics_region (mir_surface_get_buffer_stream (impl->surface), &region);
+ 
+       switch (region.pixel_format)
+@@ -473,6 +684,7 @@ gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window)
+                                                            region.width,
+                                                            region.height,
+                                                            region.stride);
++      cairo_surface_set_device_scale (cairo_surface, (double) impl->output_scale, (double) impl->output_scale);
+     }
+   else
+     cairo_surface = cairo_image_surface_create (pixel_format, 0, 0);
+@@ -506,6 +718,7 @@ gdk_mir_window_impl_finalize (GObject *object)
+ {
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (object);
+ 
++  g_free (impl->title);
+   if (impl->background)
+     cairo_pattern_destroy (impl->background);
+   if (impl->surface)
+@@ -526,6 +739,7 @@ gdk_mir_window_impl_show (GdkWindow *window,
+   //g_printerr ("gdk_mir_window_impl_show window=%p\n", window);
+ 
+   impl->visible = TRUE;
++  set_surface_state (impl, mir_surface_state_restored);
+ 
+   /* Make sure there's a surface to see */
+   ensure_surface (window);
+@@ -547,7 +761,8 @@ gdk_mir_window_impl_hide (GdkWindow *window)
+ 
+   impl->cursor_inside = FALSE;
+   impl->visible = FALSE;
+-  ensure_no_surface (window);
++
++  set_surface_state (impl, mir_surface_state_hidden);
+ }
+ 
+ static void
+@@ -558,7 +773,8 @@ gdk_mir_window_impl_withdraw (GdkWindow *window)
+ 
+   impl->cursor_inside = FALSE;
+   impl->visible = FALSE;
+-  ensure_no_surface (window);
++
++  set_surface_state (impl, mir_surface_state_hidden);
+ }
+ 
+ static void
+@@ -610,32 +826,28 @@ gdk_mir_window_impl_move_resize (GdkWindow *window,
+   g_printerr ("\n");
+   */
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+-  gboolean recreate_surface = FALSE;
+-
+-  /* Transient windows can move wherever they want */
+-  if (with_move)
+-    {
+-      if (x != impl->transient_x || y != impl->transient_y)
+-        {
+-          impl->transient_x = x;
+-          impl->transient_y = y;
+-          recreate_surface = TRUE;
+-        }
+-    }
++  //g_printerr ("gdk_mir_window_impl_move_resize window=%p, impl=%p\n", window, impl);
+ 
+   /* If resize requested then rebuild surface */
+-  if (width >= 0)
++  if (width >= 0 && (window->width != width || window->height != height))
+   {
+     /* We accept any resize */
+     window->width = width;
+     window->height = height;
+-    recreate_surface = TRUE;
++    impl->pending_redraw = TRUE;
++    impl->pending_spec_update = TRUE;
+   }
+ 
+-  if (recreate_surface && impl->surface)
++  /* Transient windows can move wherever they want */
++  if (with_move)
+     {
+-      ensure_no_surface (window);
+-      ensure_surface (window);
++      if (x != impl->transient_x || y != impl->transient_y)
++        {
++          impl->transient_x = x;
++          impl->transient_y = y;
++          if (!impl->pending_spec_update && impl->surface)
++            update_surface_spec (window);
++        }
+     }
+ }
+ 
+@@ -754,9 +966,12 @@ gdk_mir_window_impl_get_device_state (GdkWindow       *window,
+ static gboolean
+ gdk_mir_window_impl_begin_paint (GdkWindow *window)
+ {
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++
++  ensure_surface (window);
+   //g_printerr ("gdk_mir_window_impl_begin_paint window=%p\n", window);
+   /* Indicate we are ready to be drawn onto directly? */
+-  return FALSE;
++  return impl->pending_swap;
+ }
+ 
+ static void
+@@ -832,10 +1047,11 @@ gdk_mir_window_impl_set_type_hint (GdkWindow         *window,
+ {
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+ 
+-  if (hint != impl->type_hint)
++  if (type_hint_differs (hint, impl->type_hint))
+     {
+       impl->type_hint = hint;
+-      ensure_no_surface (window);
++      if (impl->surface && !impl->pending_spec_update)
++        update_surface_spec (window);
+     }
+ }
+ 
+@@ -881,15 +1097,39 @@ gdk_mir_window_impl_set_geometry_hints (GdkWindow         *window,
+                                         const GdkGeometry *geometry,
+                                         GdkWindowHints     geom_mask)
+ {
+-  //g_printerr ("gdk_mir_window_impl_set_geometry_hints window=%p\n", window);
+-  //FIXME: ?
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
++  //g_printerr ("gdk_mir_window_impl_set_geometry_hints window=%p impl=%p\n", window, impl);
++
++  impl->geometry_hints = *geometry;
++  impl->geometry_mask = geom_mask;
++
++  if (impl->surface && !impl->pending_spec_update)
++    {
++       MirSurfaceSpec* spec = mir_connection_create_spec_for_changes (connection);
++       apply_geometry_hints (spec, impl);
++       mir_surface_apply_spec (impl->surface, spec);
++       mir_surface_spec_release (spec);
++    }
+ }
+ 
+ static void
+ gdk_mir_window_impl_set_title (GdkWindow   *window,
+                                const gchar *title)
+ {
+-  // g_printerr ("gdk_mir_window_impl_set_title window=%p\n", window);
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
++  //g_printerr ("gdk_mir_window_impl_set_title window=%p\n", window);
++
++  g_free (impl->title);
++  impl->title = g_strdup (title);
++  if (impl->surface && !impl->pending_spec_update)
++    {
++       MirSurfaceSpec* spec = mir_connection_create_spec_for_changes (connection);
++       mir_surface_spec_set_name (spec, impl->title);
++       mir_surface_apply_spec (impl->surface, spec);
++       mir_surface_spec_release (spec);
++    }
+ }
+ 
+ static void
+@@ -918,6 +1158,9 @@ gdk_mir_window_impl_set_transient_for (GdkWindow *window,
+ 
+   /* Link this window to the parent */
+   impl->transient_for = parent;
++
++  if (impl->surface && !impl->pending_spec_update)
++    update_surface_spec (window);
+ }
+ 
+ static void
+@@ -1247,8 +1490,8 @@ static gint
+ gdk_mir_window_impl_get_scale_factor (GdkWindow *window)
+ {
+   //g_printerr ("gdk_mir_window_impl_get_scale_factor window=%p\n", window);
+-  /* Don't support monitor scaling */
+-  return 1;
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  return impl->output_scale;
+ }
+ 
+ static void
+@@ -1460,7 +1703,7 @@ _gdk_mir_window_get_egl_surface (GdkWindow *window,
+       ensure_surface_full (window, mir_buffer_usage_hardware);
+ 
+       egl_display = _gdk_mir_display_get_egl_display (gdk_window_get_display (window));
+-      egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (mir_surface_get_buffer_stream (impl->surface));
++      egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (impl->buffer_stream);
+ 
+       impl->egl_surface =
+         eglCreateWindowSurface (egl_display, config, egl_window, NULL);
+@@ -1485,7 +1728,7 @@ _gdk_mir_window_get_dummy_egl_surface (GdkWindow *window,
+ 
+       display = gdk_window_get_display (window);
+       egl_display = _gdk_mir_display_get_egl_display (display);
+-      egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (mir_surface_get_buffer_stream (impl->surface));
++      egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (impl->buffer_stream);
+ 
+       impl->dummy_egl_surface =
+         eglCreateWindowSurface (egl_display, config, egl_window, NULL);
+@@ -1506,6 +1749,30 @@ gdk_mir_window_get_mir_surface (GdkWindow *window)
+   return impl->surface;
+ }
+ 
++void
++_gdk_mir_window_set_surface_output (GdkWindow *window, gdouble scale)
++{
++  // g_printerr ("_gdk_mir_window_impl_set_surface_output impl=%p\n", impl);
++  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
++  GdkRectangle area = {0, 0, window->width, window->height};
++  cairo_region_t *region;
++  gint new_scale = (gint) round (scale);
++
++  if (impl->output_scale != new_scale)
++    {
++      impl->output_scale = new_scale;
++
++      drop_cairo_surface (window);
++
++      if (impl->buffer_stream)
++        mir_buffer_stream_set_scale (impl->buffer_stream, (float) new_scale);
++
++      region = cairo_region_create_rectangle (&area);
++      _gdk_window_invalidate_for_expose (window, region);
++      cairo_region_destroy (region);
++    }
++}
++
+ static void
+ gdk_mir_window_impl_class_init (GdkMirWindowImplClass *klass)
+ {
+-- 
+2.8.1
+

=== added file 'debian/patches/no_content_hub.patch'
--- debian/patches/no_content_hub.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/no_content_hub.patch	2017-06-06 19:53:49 +0000
@@ -0,0 +1,742 @@
+diff --git a/configure.ac b/configure.ac
+index 6628e218f4..dbeed73235 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -464,7 +464,7 @@ else
+   AM_CONDITIONAL(USE_WAYLAND, false)
+ fi
+ 
+-MIR_DEPENDENCIES="mirclient >= mirclient_required_version mircookie >= mircookie_required_version libcontent-hub-glib"
++MIR_DEPENDENCIES="mirclient >= mirclient_required_version mircookie >= mircookie_required_version"
+ if test "$enable_mir_backend" = "maybe" ; then
+   PKG_CHECK_EXISTS($MIR_DEPENDENCIES, [have_mir_deps=yes], [have_mir_deps=no])
+   AC_MSG_CHECKING([for MIR_DEPENDENCIES])
+diff --git a/gdk/mir/gdkmir-private.h b/gdk/mir/gdkmir-private.h
+index e726703b21..6decb0c310 100644
+--- a/gdk/mir/gdkmir-private.h
++++ b/gdk/mir/gdkmir-private.h
+@@ -115,11 +115,6 @@ void _gdk_mir_display_focus_window (GdkDisplay *display, GdkWindow *window);
+ 
+ void _gdk_mir_display_unfocus_window (GdkDisplay *display, GdkWindow *window);
+ 
+-void _gdk_mir_display_create_paste (GdkDisplay          *display,
+-                                    const gchar * const *paste_formats,
+-                                    gconstpointer        paste_data,
+-                                    gsize                paste_size);
+-
+ gboolean _gdk_mir_display_init_egl_display (GdkDisplay *display);
+ 
+ EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display);
+diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c
+index 8b39e82e3e..c4080aad78 100644
+--- a/gdk/mir/gdkmirdisplay.c
++++ b/gdk/mir/gdkmirdisplay.c
+@@ -23,10 +23,6 @@
+ #include "gdkmir.h"
+ #include "gdkmir-private.h"
+ 
+-#include <string.h>
+-
+-#include <com/ubuntu/content/glib/content-hub-glib.h>
+-
+ #define GDK_TYPE_DISPLAY_MIR              (gdk_mir_display_get_type ())
+ #define GDK_MIR_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MIR, GdkMirDisplay))
+ #define GDK_MIR_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_MIR, GdkMirDisplayClass))
+@@ -61,10 +57,6 @@ typedef struct GdkMirDisplay
+   guint have_egl_buffer_age : 1;
+   guint have_egl_swap_buffers_with_damage : 1;
+   guint have_egl_surfaceless_context : 1;
+-
+-  ContentHubService *content_service;
+-  ContentHubHandler *content_handler;
+-  GVariant *paste_data;
+ } GdkMirDisplay;
+ 
+ typedef struct GdkMirDisplayClass
+@@ -110,20 +102,12 @@ static void get_pixel_formats (MirConnection *, MirPixelFormat *sw, MirPixelForm
+ 
+ G_DEFINE_TYPE (GdkMirDisplay, gdk_mir_display, GDK_TYPE_DISPLAY)
+ 
+-static void
+-pasteboard_changed_cb (GdkMirDisplay *display,
+-                       gpointer       user_data)
+-{
+-  g_clear_pointer (&display->paste_data, g_variant_unref);
+-}
+-
+ GdkDisplay *
+ _gdk_mir_display_open (const gchar *display_name)
+ {
+   MirConnection *connection;
+   MirPixelFormat sw_pixel_format, hw_pixel_format;
+   GdkMirDisplay *display;
+-  GDBusConnection *session;
+ 
+   connection = mir_connect_sync (NULL, g_get_prgname ());
+   if (!connection)
+@@ -153,45 +137,6 @@ _gdk_mir_display_open (const gchar *display_name)
+   display->sw_pixel_format = sw_pixel_format;
+   display->hw_pixel_format = hw_pixel_format;
+ 
+-  session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
+-
+-  display->content_service = content_hub_service_proxy_new_sync (
+-    session,
+-    G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
+-    "com.ubuntu.content.dbus.Service",
+-    "/",
+-    NULL,
+-    NULL);
+-
+-  g_signal_connect_swapped (
+-    display->content_service,
+-    "pasteboard-changed",
+-    G_CALLBACK (pasteboard_changed_cb),
+-    display);
+-
+-  display->content_handler = content_hub_handler_skeleton_new ();
+-
+-  g_dbus_interface_skeleton_export (
+-    G_DBUS_INTERFACE_SKELETON (display->content_handler),
+-    session,
+-    "/org/gnome/gtk/content/handler",
+-    NULL);
+-
+-  g_object_unref (session);
+-
+-  content_hub_service_call_register_import_export_handler_sync (
+-    display->content_service,
+-    g_application_get_application_id (g_application_get_default ()),
+-    "/org/gnome/gtk/content/handler",
+-    NULL,
+-    NULL);
+-
+-  content_hub_service_call_handler_active_sync (
+-    display->content_service,
+-    g_application_get_application_id (g_application_get_default ()),
+-    NULL,
+-    NULL);
+-
+   g_signal_emit_by_name (display, "opened");
+ 
+   return GDK_DISPLAY (display);
+@@ -227,10 +172,6 @@ gdk_mir_display_dispose (GObject *object)
+ {
+   GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
+ 
+-  g_clear_pointer (&display->paste_data, g_variant_unref);
+-  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (display->content_handler));
+-  g_clear_object (&display->content_handler);
+-  g_clear_object (&display->content_service);
+   g_clear_object (&display->screen);
+   g_clear_object (&display->keymap);
+   g_clear_pointer (&display->event_source, g_source_unref);
+@@ -482,28 +423,7 @@ gdk_mir_display_set_selection_owner (GdkDisplay *display,
+                                      guint32     time,
+                                      gboolean    send_event)
+ {
+-  GdkEvent *event;
+-
+-  if (selection == GDK_SELECTION_CLIPBOARD)
+-    {
+-      if (owner)
+-        {
+-          event = gdk_event_new (GDK_SELECTION_REQUEST);
+-          event->selection.window = g_object_ref (owner);
+-          event->selection.send_event = FALSE;
+-          event->selection.selection = selection;
+-          event->selection.target = gdk_atom_intern_static_string ("TARGETS");
+-          event->selection.property = gdk_atom_intern_static_string ("AVAILABLE_TARGETS");
+-          event->selection.time = GDK_CURRENT_TIME;
+-          event->selection.requestor = g_object_ref (owner);
+-
+-          gdk_event_put (event);
+-          gdk_event_free (event);
+-
+-          return TRUE;
+-        }
+-    }
+-
++  //g_printerr ("gdk_mir_display_set_selection_owner\n");
+   return FALSE;
+ }
+ 
+@@ -524,261 +444,10 @@ gdk_mir_display_get_selection_property (GdkDisplay  *display,
+                                         GdkAtom     *ret_type,
+                                         gint        *ret_format)
+ {
+-  gint length;
+-
+-  gdk_property_get (requestor,
+-                    gdk_atom_intern_static_string ("GDK_SELECTION"),
+-                    GDK_NONE,
+-                    0,
+-                    G_MAXULONG,
+-                    FALSE,
+-                    ret_type,
+-                    ret_format,
+-                    &length,
+-                    data);
+-
+-  return length;
+-}
+-
+-static gint
+-get_format_score (const gchar *format,
+-                  GdkAtom      target,
+-                  GdkAtom     *out_type,
+-                  gint        *out_size)
+-{
+-  const gchar *target_string;
+-  GdkAtom dummy_type;
+-  gint dummy_size;
+-
+-  target_string = _gdk_atom_name_const (target);
+-
+-  if (!out_type)
+-    out_type = &dummy_type;
+-
+-  if (!out_size)
+-    out_size = &dummy_size;
+-
+-  if (!g_ascii_strcasecmp (format, target_string))
+-    {
+-      *out_type = GDK_SELECTION_TYPE_STRING;
+-      *out_size = sizeof (guchar);
+-
+-      return G_MAXINT;
+-    }
+-
+-  if (target == gdk_atom_intern_static_string ("UTF8_STRING"))
+-    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), out_type, out_size);
+-
+-  /* TODO: use best media type for COMPOUND_TEXT target */
+-  if (target == gdk_atom_intern_static_string ("COMPOUND_TEXT"))
+-    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), out_type, out_size);
+-
+-  if (target == GDK_TARGET_STRING)
+-    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=iso-8859-1"), out_type, out_size);
+-
+-  if (target == gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
+-    return get_format_score (format, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), out_type, out_size);
+-
+-  if (g_content_type_is_a (format, target_string))
+-    {
+-      *out_type = GDK_SELECTION_TYPE_STRING;
+-      *out_size = sizeof (guchar);
+-
+-      return 2;
+-    }
+-
+-  if (g_content_type_is_a (target_string, format))
+-    {
+-      *out_type = GDK_SELECTION_TYPE_STRING;
+-      *out_size = sizeof (guchar);
+-
+-      return 1;
+-    }
+-
++  //g_printerr ("gdk_mir_display_get_selection_property\n");
+   return 0;
+ }
+ 
+-static gint
+-get_best_format_index (const gchar * const *formats,
+-                       guint                n_formats,
+-                       GdkAtom              target,
+-                       GdkAtom             *out_type,
+-                       gint                *out_size)
+-{
+-  gint best_i = -1;
+-  gint best_score = 0;
+-  GdkAtom best_type;
+-  gint best_size;
+-  gint score;
+-  GdkAtom type;
+-  gint size;
+-  gint i;
+-
+-  if (!out_type)
+-    out_type = &best_type;
+-
+-  if (!out_size)
+-    out_size = &best_size;
+-
+-  *out_type = GDK_NONE;
+-  *out_size = 0;
+-
+-  for (i = 0; i < n_formats; i++)
+-    {
+-      score = get_format_score (formats[i], target, &type, &size);
+-
+-      if (score > best_score)
+-        {
+-          best_i = i;
+-          best_score = score;
+-          *out_type = type;
+-          *out_size = size;
+-        }
+-    }
+-
+-  return best_i;
+-}
+-
+-static void
+-gdk_mir_display_real_convert_selection (GdkDisplay *display,
+-                                        GdkWindow  *requestor,
+-                                        GdkAtom     selection,
+-                                        GdkAtom     target,
+-                                        guint32     time)
+-{
+-  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
+-  const gchar *paste_data;
+-  gsize paste_size;
+-  const gint *paste_header;
+-  GPtrArray *paste_formats;
+-  GArray *paste_targets;
+-  GdkAtom paste_target;
+-  GdkEvent *event;
+-  gint best_i;
+-  GdkAtom best_type;
+-  gint best_size;
+-  gint i;
+-
+-  g_return_if_fail (mir_display->paste_data);
+-
+-  paste_data = g_variant_get_fixed_array (mir_display->paste_data, &paste_size, sizeof (guchar));
+-  paste_header = (const gint *) paste_data;
+-
+-  if (paste_data)
+-    {
+-      paste_formats = g_ptr_array_new_full (paste_header[0], g_free);
+-
+-      for (i = 0; i < paste_header[0]; i++)
+-        g_ptr_array_add (paste_formats, g_strndup (paste_data + paste_header[1 + 4 * i], paste_header[2 + 4 * i]));
+-    }
+-  else
+-    paste_formats = g_ptr_array_new_with_free_func (g_free);
+-
+-  if (target == gdk_atom_intern_static_string ("TARGETS"))
+-    {
+-      paste_targets = g_array_sized_new (TRUE, FALSE, sizeof (GdkAtom), paste_formats->len);
+-
+-      for (i = 0; i < paste_formats->len; i++)
+-        {
+-          paste_target = gdk_atom_intern (g_ptr_array_index (paste_formats, i), FALSE);
+-          g_array_append_val (paste_targets, paste_target);
+-        }
+-
+-      gdk_property_change (requestor,
+-                           gdk_atom_intern_static_string ("GDK_SELECTION"),
+-                           GDK_SELECTION_TYPE_ATOM,
+-                           8 * sizeof (GdkAtom),
+-                           GDK_PROP_MODE_REPLACE,
+-                           (const guchar *) paste_targets->data,
+-                           paste_targets->len);
+-
+-      g_array_unref (paste_targets);
+-
+-      event = gdk_event_new (GDK_SELECTION_NOTIFY);
+-      event->selection.window = g_object_ref (requestor);
+-      event->selection.send_event = FALSE;
+-      event->selection.selection = selection;
+-      event->selection.target = target;
+-      event->selection.property = gdk_atom_intern_static_string ("GDK_SELECTION");
+-      event->selection.time = time;
+-      event->selection.requestor = g_object_ref (requestor);
+-
+-      gdk_event_put (event);
+-      gdk_event_free (event);
+-    }
+-  else
+-    {
+-      best_i = get_best_format_index ((const gchar * const *) paste_formats->pdata,
+-                                      paste_formats->len,
+-                                      target,
+-                                      &best_type,
+-                                      &best_size);
+-
+-      if (best_i >= 0)
+-        {
+-          gdk_property_change (requestor,
+-                               gdk_atom_intern_static_string ("GDK_SELECTION"),
+-                               best_type,
+-                               8 * best_size,
+-                               GDK_PROP_MODE_REPLACE,
+-                               (const guchar *) paste_data + paste_header[3 + 4 * best_i],
+-                               paste_header[4 + 4 * best_i] / best_size);
+-
+-          event = gdk_event_new (GDK_SELECTION_NOTIFY);
+-          event->selection.window = g_object_ref (requestor);
+-          event->selection.send_event = FALSE;
+-          event->selection.selection = selection;
+-          event->selection.target = target;
+-          event->selection.property = gdk_atom_intern_static_string ("GDK_SELECTION");
+-          event->selection.time = time;
+-          event->selection.requestor = g_object_ref (requestor);
+-
+-          gdk_event_put (event);
+-          gdk_event_free (event);
+-        }
+-    }
+-
+-  g_ptr_array_unref (paste_formats);
+-}
+-
+-typedef struct
+-{
+-  GdkDisplay *display;
+-  GdkWindow  *requestor;
+-  GdkAtom     selection;
+-  GdkAtom     target;
+-  guint32     time;
+-} ConvertInfo;
+-
+-static void
+-paste_data_ready_cb (GObject      *source_object,
+-                     GAsyncResult *res,
+-                     gpointer      user_data)
+-{
+-  ContentHubService *content_service = CONTENT_HUB_SERVICE (source_object);
+-  ConvertInfo *info = user_data;
+-  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (info->display);
+-  gboolean result;
+-
+-  g_clear_pointer (&mir_display->paste_data, g_variant_unref);
+-
+-  result = content_hub_service_call_get_latest_paste_data_finish (content_service,
+-                                                                  &mir_display->paste_data,
+-                                                                  res,
+-                                                                  NULL);
+-
+-  if (result)
+-    gdk_mir_display_real_convert_selection (info->display,
+-                                            info->requestor,
+-                                            info->selection,
+-                                            info->target,
+-                                            info->time);
+-
+-  g_object_unref (info->requestor);
+-  g_object_unref (info->display);
+-  g_free (info);
+-}
+-
+ static void
+ gdk_mir_display_convert_selection (GdkDisplay *display,
+                                    GdkWindow  *requestor,
+@@ -786,46 +455,7 @@ gdk_mir_display_convert_selection (GdkDisplay *display,
+                                    GdkAtom     target,
+                                    guint32     time)
+ {
+-  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
+-  MirWindow *mir_window;
+-  MirWindowId *mir_window_id;
+-  ConvertInfo *info;
+-
+-  if (selection != GDK_SELECTION_CLIPBOARD)
+-    return;
+-  else if (mir_display->paste_data)
+-    gdk_mir_display_real_convert_selection (display, requestor, selection, target, time);
+-  else if (mir_display->focused_window)
+-    {
+-      mir_window = _gdk_mir_window_get_mir_window (mir_display->focused_window);
+-
+-      if (!mir_window)
+-        return;
+-
+-      mir_window_id = mir_window_request_window_id_sync (mir_window);
+-
+-      if (!mir_window_id)
+-        return;
+-
+-      if (mir_window_id_is_valid (mir_window_id))
+-        {
+-          info = g_new (ConvertInfo, 1);
+-          info->display = g_object_ref (display);
+-          info->requestor = g_object_ref (requestor);
+-          info->selection = selection;
+-          info->target = target;
+-          info->time = time;
+-
+-          content_hub_service_call_get_latest_paste_data (
+-            mir_display->content_service,
+-            mir_window_id_as_string (mir_window_id),
+-            NULL,
+-            paste_data_ready_cb,
+-            info);
+-        }
+-
+-      mir_window_id_release (mir_window_id);
+-    }
++  //g_printerr ("gdk_mir_display_convert_selection\n");
+ }
+ 
+ static gint
+@@ -836,38 +466,8 @@ gdk_mir_display_text_property_to_utf8_list (GdkDisplay    *display,
+                                             gint           length,
+                                             gchar       ***list)
+ {
+-  GPtrArray *array;
+-  const gchar *ptr;
+-  gsize chunk_len;
+-  gchar *copy;
+-  guint nitems;
+-
+-  ptr = (const gchar *) text;
+-  array = g_ptr_array_new ();
+-
+-  /* split text into utf-8 strings */
+-  while (ptr < (const gchar *) &text[length])
+-    {
+-      chunk_len = strlen (ptr);
+-
+-      if (g_utf8_validate (ptr, chunk_len, NULL))
+-        {
+-          copy = g_strndup (ptr, chunk_len);
+-          g_ptr_array_add (array, copy);
+-        }
+-
+-      ptr = &ptr[chunk_len + 1];
+-    }
+-
+-  nitems = array->len;
+-  g_ptr_array_add (array, NULL);
+-
+-  if (list)
+-    *list = (gchar **) g_ptr_array_free (array, FALSE);
+-  else
+-    g_ptr_array_free (array, TRUE);
+-
+-  return nitems;
++  //g_printerr ("gdk_mir_display_text_property_to_utf8_list\n");
++  return 0;
+ }
+ 
+ static gchar *
+@@ -962,43 +562,6 @@ _gdk_mir_display_unfocus_window (GdkDisplay *display,
+     g_clear_object (&mir_display->focused_window);
+ }
+ 
+-void
+-_gdk_mir_display_create_paste (GdkDisplay          *display,
+-                               const gchar * const *paste_formats,
+-                               gconstpointer        paste_data,
+-                               gsize                paste_size)
+-{
+-  GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
+-  MirWindow *mir_window;
+-  MirWindowId *mir_window_id;
+-
+-  if (!mir_display->focused_window)
+-    return;
+-
+-  mir_window = _gdk_mir_window_get_mir_window (mir_display->focused_window);
+-
+-  if (!mir_window)
+-    return;
+-
+-  mir_window_id = mir_window_request_window_id_sync (mir_window);
+-
+-  if (!mir_window_id)
+-    return;
+-
+-  if (mir_window_id_is_valid (mir_window_id))
+-    content_hub_service_call_create_paste_sync (
+-      mir_display->content_service,
+-      g_application_get_application_id (g_application_get_default ()),
+-      mir_window_id_as_string (mir_window_id),
+-      g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, paste_data, paste_size, sizeof (guchar)),
+-      paste_formats,
+-      NULL,
+-      NULL,
+-      NULL);
+-
+-  mir_window_id_release (mir_window_id);
+-}
+-
+ gboolean
+ _gdk_mir_display_init_egl_display (GdkDisplay *display)
+ {
+diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c
+index 9f9107611e..320414fb0a 100644
+--- a/gdk/mir/gdkmirwindowimpl.c
++++ b/gdk/mir/gdkmirwindowimpl.c
+@@ -1899,140 +1899,6 @@ gdk_mir_window_impl_get_property (GdkWindow  *window,
+ }
+ 
+ static void
+-request_targets (GdkWindow     *window,
+-                 const GdkAtom *available_targets,
+-                 gint           n_available_targets)
+-{
+-  GArray *requested_targets;
+-  GdkAtom target_pair[2];
+-  gchar *target_location;
+-  GdkEvent *event;
+-  gint i;
+-
+-  requested_targets = g_array_sized_new (TRUE, FALSE, sizeof (GdkAtom), 2 * n_available_targets);
+-
+-  for (i = 0; i < n_available_targets; i++)
+-    {
+-      target_pair[0] = available_targets[i];
+-
+-      if (target_pair[0] == gdk_atom_intern_static_string ("TIMESTAMP") ||
+-          target_pair[0] == gdk_atom_intern_static_string ("TARGETS") ||
+-          target_pair[0] == gdk_atom_intern_static_string ("MULTIPLE") ||
+-          target_pair[0] == gdk_atom_intern_static_string ("SAVE_TARGETS"))
+-        continue;
+-
+-      target_location = g_strdup_printf ("REQUESTED_TARGET_U%u", requested_targets->len / 2);
+-      target_pair[1] = gdk_atom_intern (target_location, FALSE);
+-      g_free (target_location);
+-
+-      g_array_append_vals (requested_targets, target_pair, 2);
+-    }
+-
+-  gdk_property_delete (window, gdk_atom_intern_static_string ("AVAILABLE_TARGETS"));
+-  gdk_property_delete (window, gdk_atom_intern_static_string ("REQUESTED_TARGETS"));
+-
+-  gdk_property_change (window,
+-                       gdk_atom_intern_static_string ("REQUESTED_TARGETS"),
+-                       GDK_SELECTION_TYPE_ATOM,
+-                       8 * sizeof (GdkAtom),
+-                       GDK_PROP_MODE_REPLACE,
+-                       (const guchar *) requested_targets->data,
+-                       requested_targets->len);
+-
+-  g_array_unref (requested_targets);
+-
+-  event = gdk_event_new (GDK_SELECTION_REQUEST);
+-  event->selection.window = g_object_ref (window);
+-  event->selection.send_event = FALSE;
+-  event->selection.selection = GDK_SELECTION_CLIPBOARD;
+-  event->selection.target = gdk_atom_intern_static_string ("MULTIPLE");
+-  event->selection.property = gdk_atom_intern_static_string ("REQUESTED_TARGETS");
+-  event->selection.time = GDK_CURRENT_TIME;
+-  event->selection.requestor = g_object_ref (window);
+-
+-  gdk_event_put (event);
+-  gdk_event_free (event);
+-}
+-
+-static void
+-create_paste (GdkWindow     *window,
+-              const GdkAtom *requested_targets,
+-              gint           n_requested_targets)
+-{
+-  GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+-  GPtrArray *paste_formats;
+-  GArray *paste_header;
+-  GByteArray *paste_data;
+-  gint sizes[4];
+-  GdkMirProperty *mir_property;
+-  const gchar *paste_format;
+-  gint i;
+-
+-  paste_formats = g_ptr_array_new_full (n_requested_targets, g_free);
+-  paste_header = g_array_sized_new (FALSE, FALSE, sizeof (gint), 1 + 4 * n_requested_targets);
+-  paste_data = g_byte_array_new ();
+-
+-  g_array_append_val (paste_header, sizes[0]);
+-
+-  for (i = 0; i < n_requested_targets; i++)
+-    {
+-      if (requested_targets[i] == GDK_NONE)
+-        continue;
+-
+-      mir_property = g_hash_table_lookup (impl->properties, requested_targets[i]);
+-
+-      if (!mir_property)
+-        continue;
+-
+-      paste_format = _gdk_atom_name_const (mir_property->type);
+-
+-      /* skip non-MIME targets */
+-      if (!strchr (paste_format, '/'))
+-        {
+-          g_hash_table_remove (impl->properties, requested_targets[i]);
+-          continue;
+-        }
+-
+-      sizes[0] = paste_data->len;
+-      sizes[1] = strlen (paste_format);
+-      sizes[2] = sizes[0] + sizes[1];
+-      sizes[3] = mir_property->array->len * g_array_get_element_size (mir_property->array);
+-
+-      g_ptr_array_add (paste_formats, g_strdup (paste_format));
+-      g_array_append_vals (paste_header, sizes, 4);
+-      g_byte_array_append (paste_data, (const guint8 *) paste_format, sizes[1]);
+-      g_byte_array_append (paste_data, (const guint8 *) mir_property->array->data, sizes[3]);
+-
+-      g_hash_table_remove (impl->properties, requested_targets[i]);
+-    }
+-
+-  gdk_property_delete (window, gdk_atom_intern_static_string ("REQUESTED_TARGETS"));
+-
+-  g_array_index (paste_header, gint, 0) = paste_formats->len;
+-
+-  for (i = 0; i < paste_formats->len; i++)
+-    {
+-      g_array_index (paste_header, gint, 1 + 4 * i) += paste_header->len * sizeof (gint);
+-      g_array_index (paste_header, gint, 3 + 4 * i) += paste_header->len * sizeof (gint);
+-    }
+-
+-  g_byte_array_prepend (paste_data,
+-                        (const guint8 *) paste_header->data,
+-                        paste_header->len * g_array_get_element_size (paste_header));
+-
+-  g_ptr_array_add (paste_formats, NULL);
+-
+-  _gdk_mir_display_create_paste (gdk_window_get_display (window),
+-                                 (const gchar * const *) paste_formats->pdata,
+-                                 paste_data->data,
+-                                 paste_data->len);
+-
+-  g_byte_array_unref (paste_data);
+-  g_array_unref (paste_header);
+-  g_ptr_array_unref (paste_formats);
+-}
+-
+-static void
+ gdk_mir_window_impl_change_property (GdkWindow    *window,
+                                      GdkAtom       property,
+                                      GdkAtom       type,
+@@ -2043,7 +1909,6 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+ {
+   GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+   GdkMirProperty *mir_property;
+-  gboolean existed;
+   GdkEvent *event;
+ 
+   /* ICCCM 2.7: ATOMs and ATOM_PAIRs have format 32, but GdkAtoms can be 64-bit */
+@@ -2051,15 +1916,9 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+     format = 8 * sizeof (GdkAtom);
+ 
+   if (mode != GDK_PROP_MODE_REPLACE)
+-    {
+-      mir_property = g_hash_table_lookup (impl->properties, property);
+-      existed = mir_property != NULL;
+-    }
++    mir_property = g_hash_table_lookup (impl->properties, property);
+   else
+-    {
+-      mir_property = NULL;
+-      existed = g_hash_table_contains (impl->properties, property);
+-    }
++    mir_property = NULL;
+ 
+   if (!mir_property)
+     {
+@@ -2086,11 +1945,6 @@ gdk_mir_window_impl_change_property (GdkWindow    *window,
+ 
+   gdk_event_put (event);
+   gdk_event_free (event);
+-
+-  if (property == gdk_atom_intern_static_string ("AVAILABLE_TARGETS"))
+-    request_targets (window, (const GdkAtom *) data, n_elements);
+-  else if (property == gdk_atom_intern_static_string ("REQUESTED_TARGETS") && existed)
+-    create_paste (window, (const GdkAtom *) data, n_elements);
+ }
+ 
+ static void

=== modified file 'debian/patches/series'
--- debian/patches/series	2017-05-01 03:03:50 +0000
+++ debian/patches/series	2017-06-06 19:53:49 +0000
@@ -23,3 +23,4 @@
 unity-border-radius.patch
 unity-headerbar-maximized-mode.patch
 gtksocket-unscale-before-sending-configurenotify.patch
+no_content_hub.patch

=== modified file 'debian/rules'
--- debian/rules	2017-05-15 09:55:48 +0000
+++ debian/rules	2017-06-06 19:53:49 +0000
@@ -73,7 +73,7 @@
 
 DEB_CONFIGURE_FLAGS_shared = \
 			--enable-broadway-backend \
-			--disable-mir-backend \
+			--enable-mir-backend \
 			--enable-x11-backend \
 			--enable-gtk-doc \
 			--enable-man \