path: root/mail-client/thunderbird/files/firefox-wayland.patch

diff -up thunderbird-60.5.0/widget/gtk/GtkCompositorWidget.cpp.wayland thunderbird-60.5.0/widget/gtk/GtkCompositorWidget.cpp
--- thunderbird-60.5.0/widget/gtk/GtkCompositorWidget.cpp.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/GtkCompositorWidget.cpp	2019-02-05 14:26:16.973316654 +0100
@@ -38,7 +38,9 @@ GtkCompositorWidget::GtkCompositorWidget
 
     // Grab the window's visual and depth
     XWindowAttributes windowAttrs;
-    XGetWindowAttributes(mXDisplay, mXWindow, &windowAttrs);
+    if (!XGetWindowAttributes(mXDisplay, mXWindow, &windowAttrs)) {
+      NS_WARNING("GtkCompositorWidget(): XGetWindowAttributes() failed!");
+    }
 
     Visual* visual = windowAttrs.visual;
     int depth = windowAttrs.depth;
diff -up thunderbird-60.5.0/widget/gtk/moz.build.wayland thunderbird-60.5.0/widget/gtk/moz.build
--- thunderbird-60.5.0/widget/gtk/moz.build.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/moz.build	2019-02-05 14:26:16.974316651 +0100
@@ -99,6 +99,7 @@ if CONFIG['MOZ_X11']:
 if CONFIG['MOZ_WAYLAND']:
     UNIFIED_SOURCES += [
         'nsClipboardWayland.cpp',
+        'nsWaylandDisplay.cpp',
         'WindowSurfaceWayland.cpp',
     ]
 
@@ -123,6 +124,7 @@ include('/ipc/chromium/chromium-config.m
 FINAL_LIBRARY = 'xul'
 
 LOCAL_INCLUDES += [
+    '/layout/base',
     '/layout/generic',
     '/layout/xul',
     '/other-licenses/atk-1.0',
diff -up thunderbird-60.5.0/widget/gtk/mozcontainer.cpp.wayland thunderbird-60.5.0/widget/gtk/mozcontainer.cpp
--- thunderbird-60.5.0/widget/gtk/mozcontainer.cpp.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/mozcontainer.cpp	2019-02-05 15:09:24.116970135 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -7,9 +7,10 @@
 
 #include "mozcontainer.h"
 #include <gtk/gtk.h>
-#ifdef MOZ_WAYLAND
 #include <gdk/gdkx.h>
-#include <gdk/gdkwayland.h>
+#ifdef MOZ_WAYLAND
+#include "nsWaylandDisplay.h"
+#include <wayland-egl.h>
 #endif
 #include <stdio.h>
 #include <dlfcn.h>
@@ -19,12 +20,20 @@
 #include "maiRedundantObjectFactory.h"
 #endif
 
+#ifdef MOZ_WAYLAND
+using namespace mozilla;
+using namespace mozilla::widget;
+#endif
+
 /* init methods */
 static void moz_container_class_init(MozContainerClass *klass);
 static void moz_container_init(MozContainer *container);
 
 /* widget class methods */
 static void moz_container_map(GtkWidget *widget);
+#if defined(MOZ_WAYLAND)
+static gboolean moz_container_map_wayland(GtkWidget *widget, GdkEventAny *event);
+#endif
 static void moz_container_unmap(GtkWidget *widget);
 static void moz_container_realize(GtkWidget *widget);
 static void moz_container_size_allocate(GtkWidget *widget,
@@ -114,29 +123,6 @@ void moz_container_put(MozContainer *con
   gtk_widget_set_parent(child_widget, GTK_WIDGET(container));
 }
 
-void moz_container_move(MozContainer *container, GtkWidget *child_widget,
-                        gint x, gint y, gint width, gint height) {
-  MozContainerChild *child;
-  GtkAllocation new_allocation;
-
-  child = moz_container_get_child(container, child_widget);
-
-  child->x = x;
-  child->y = y;
-
-  new_allocation.x = x;
-  new_allocation.y = y;
-  new_allocation.width = width;
-  new_allocation.height = height;
-
-  /* printf("moz_container_move %p %p will allocate to %d %d %d %d\n",
-     (void *)container, (void *)child_widget,
-     new_allocation.x, new_allocation.y,
-     new_allocation.width, new_allocation.height); */
-
-  gtk_widget_size_allocate(child_widget, &new_allocation);
-}
-
 /* static methods */
 
 void moz_container_class_init(MozContainerClass *klass) {
@@ -146,6 +132,11 @@ void moz_container_class_init(MozContain
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
 
   widget_class->map = moz_container_map;
+#if defined(MOZ_WAYLAND)
+    if (!GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
+      widget_class->map_event = moz_container_map_wayland;
+    }
+#endif
   widget_class->unmap = moz_container_unmap;
   widget_class->realize = moz_container_realize;
   widget_class->size_allocate = moz_container_size_allocate;
@@ -155,109 +146,81 @@ void moz_container_class_init(MozContain
   container_class->add = moz_container_add;
 }
 
-#if defined(MOZ_WAYLAND)
-static void registry_handle_global(void *data, struct wl_registry *registry,
-                                   uint32_t name, const char *interface,
-                                   uint32_t version) {
-  MozContainer *container = MOZ_CONTAINER(data);
-  if (strcmp(interface, "wl_subcompositor") == 0) {
-    container->subcompositor = static_cast<wl_subcompositor *>(
-        wl_registry_bind(registry, name, &wl_subcompositor_interface, 1));
-  }
-}
-
-static void registry_handle_global_remove(void *data,
-                                          struct wl_registry *registry,
-                                          uint32_t name) {}
-
-static const struct wl_registry_listener registry_listener = {
-    registry_handle_global, registry_handle_global_remove};
-#endif
-
 void moz_container_init(MozContainer *container) {
   gtk_widget_set_can_focus(GTK_WIDGET(container), TRUE);
   gtk_container_set_resize_mode(GTK_CONTAINER(container), GTK_RESIZE_IMMEDIATE);
   gtk_widget_set_redraw_on_allocate(GTK_WIDGET(container), FALSE);
 
 #if defined(MOZ_WAYLAND)
-  {
-    GdkDisplay *gdk_display = gtk_widget_get_display(GTK_WIDGET(container));
-    if (GDK_IS_WAYLAND_DISPLAY(gdk_display)) {
-      // Available as of GTK 3.8+
-      static auto sGdkWaylandDisplayGetWlDisplay =
-          (wl_display * (*)(GdkDisplay *))
-              dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_display");
-
-      wl_display *display = sGdkWaylandDisplayGetWlDisplay(gdk_display);
-      wl_registry *registry = wl_display_get_registry(display);
-      wl_registry_add_listener(registry, &registry_listener, container);
-      wl_display_dispatch(display);
-      wl_display_roundtrip(display);
-    }
-  }
+  container->surface = nullptr;
+  container->subsurface = nullptr;
+  container->eglwindow = nullptr;
+  container->frame_callback_handler = nullptr;
+  // We can draw to x11 window any time.
+  container->ready_to_draw = GDK_IS_X11_DISPLAY(gdk_display_get_default());
+  container->surface_needs_clear = true;
 #endif
 }
 
 #if defined(MOZ_WAYLAND)
-/* We want to draw to GdkWindow owned by mContainer from Compositor thread but
- * Gtk+ can be used in main thread only. So we create wayland wl_surface
- * and attach it as an overlay to GdkWindow.
- *
- * see gtk_clutter_embed_ensure_subsurface() at gtk-clutter-embed.c
- *  for reference.
- */
-static gboolean moz_container_map_surface(MozContainer *container) {
-  // Available as of GTK 3.8+
-  static auto sGdkWaylandDisplayGetWlCompositor =
-      (wl_compositor * (*)(GdkDisplay *))
-          dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_compositor");
+static wl_surface *moz_container_get_gtk_container_surface(
+    MozContainer *container) {
   static auto sGdkWaylandWindowGetWlSurface = (wl_surface * (*)(GdkWindow *))
       dlsym(RTLD_DEFAULT, "gdk_wayland_window_get_wl_surface");
 
-  GdkDisplay *display = gtk_widget_get_display(GTK_WIDGET(container));
-  if (GDK_IS_X11_DISPLAY(display)) return false;
+  GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
+  return sGdkWaylandWindowGetWlSurface(window);
+}
 
-  if (container->subsurface && container->surface) return true;
+static void frame_callback_handler(void *data, struct wl_callback *callback,
+                                   uint32_t time) {
+  MozContainer *container = MOZ_CONTAINER(data);
+  g_clear_pointer(&container->frame_callback_handler, wl_callback_destroy);
+  container->ready_to_draw = true;
+}
 
-  if (!container->surface) {
-    struct wl_compositor *compositor;
-    compositor = sGdkWaylandDisplayGetWlCompositor(display);
-    container->surface = wl_compositor_create_surface(compositor);
-  }
+static const struct wl_callback_listener frame_listener = {
+    frame_callback_handler};
 
-  if (!container->subsurface) {
-    GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
-    wl_surface *gtk_surface = sGdkWaylandWindowGetWlSurface(window);
-    if (!gtk_surface) {
-      // We requested the underlying wl_surface too early when container
-      // is not realized yet. We'll try again before first rendering
-      // to mContainer.
-      return false;
-    }
+static gboolean moz_container_map_wayland(GtkWidget *widget, GdkEventAny *event) {
+  MozContainer* container = MOZ_CONTAINER(widget);
 
-    container->subsurface = wl_subcompositor_get_subsurface(
-        container->subcompositor, container->surface, gtk_surface);
-    gint x, y;
-    gdk_window_get_position(window, &x, &y);
-    wl_subsurface_set_position(container->subsurface, x, y);
-    wl_subsurface_set_desync(container->subsurface);
+  if (container->ready_to_draw || container->frame_callback_handler) {
+    return FALSE;
+  }
 
-    // Route input to parent wl_surface owned by Gtk+ so we get input
-    // events from Gtk+.
-    GdkDisplay *display = gtk_widget_get_display(GTK_WIDGET(container));
-    wl_compositor *compositor = sGdkWaylandDisplayGetWlCompositor(display);
-    wl_region *region = wl_compositor_create_region(compositor);
-    wl_surface_set_input_region(container->surface, region);
-    wl_region_destroy(region);
+  wl_surface *gtk_container_surface =
+      moz_container_get_gtk_container_surface(container);
+
+  if (gtk_container_surface) {
+    container->frame_callback_handler = wl_surface_frame(gtk_container_surface);
+    wl_callback_add_listener(container->frame_callback_handler, &frame_listener,
+                             container);
   }
-  return true;
+
+  return FALSE;
 }
 
-static void moz_container_unmap_surface(MozContainer *container) {
+static void moz_container_unmap_wayland(MozContainer *container) {
   g_clear_pointer(&container->subsurface, wl_subsurface_destroy);
   g_clear_pointer(&container->surface, wl_surface_destroy);
+  g_clear_pointer(&container->frame_callback_handler, wl_callback_destroy);
+
+  container->surface_needs_clear = true;
+  container->ready_to_draw = false;
 }
 
+static gint moz_container_get_scale(MozContainer *container) {
+    static auto sGdkWindowGetScaleFactorPtr = (gint(*)(GdkWindow *))dlsym(
+        RTLD_DEFAULT, "gdk_window_get_scale_factor");
+
+    if (sGdkWindowGetScaleFactorPtr) {
+      GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
+      return (*sGdkWindowGetScaleFactorPtr)(window);
+    }
+
+    return 1;
+}
 #endif
 
 void moz_container_map(GtkWidget *widget) {
@@ -283,7 +246,9 @@ void moz_container_map(GtkWidget *widget
   if (gtk_widget_get_has_window(widget)) {
     gdk_window_show(gtk_widget_get_window(widget));
 #if defined(MOZ_WAYLAND)
-    moz_container_map_surface(MOZ_CONTAINER(widget));
+    if (!GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
+      moz_container_map_wayland(widget, nullptr);
+    }
 #endif
   }
 }
@@ -296,7 +261,9 @@ void moz_container_unmap(GtkWidget *widg
   if (gtk_widget_get_has_window(widget)) {
     gdk_window_hide(gtk_widget_get_window(widget));
 #if defined(MOZ_WAYLAND)
-    moz_container_unmap_surface(MOZ_CONTAINER(widget));
+    if (!GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
+      moz_container_unmap_wayland(MOZ_CONTAINER(widget));
+    }
 #endif
   }
 }
@@ -485,13 +452,62 @@ static void moz_container_add(GtkContain
 
 #ifdef MOZ_WAYLAND
 struct wl_surface *moz_container_get_wl_surface(MozContainer *container) {
-  if (!container->subsurface || !container->surface) {
+  if (!container->surface) {
+    if (!container->ready_to_draw) {
+      return nullptr;
+    }
+    GdkDisplay *display = gtk_widget_get_display(GTK_WIDGET(container));
+
+    // Available as of GTK 3.8+
+    static auto sGdkWaylandDisplayGetWlCompositor =
+        (wl_compositor * (*)(GdkDisplay *))
+            dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_compositor");
+    struct wl_compositor *compositor =
+        sGdkWaylandDisplayGetWlCompositor(display);
+    container->surface = wl_compositor_create_surface(compositor);
+
+    nsWaylandDisplay *waylandDisplay = WaylandDisplayGet(display);
+    container->subsurface = wl_subcompositor_get_subsurface(
+        waylandDisplay->GetSubcompositor(), container->surface,
+        moz_container_get_gtk_container_surface(container));
+    WaylandDisplayRelease(waylandDisplay);
+
     GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
-    if (!gdk_window_is_visible(window)) return nullptr;
+    gint x, y;
+    gdk_window_get_position(window, &x, &y);
+    wl_subsurface_set_position(container->subsurface, x, y);
+    wl_subsurface_set_desync(container->subsurface);
 
-    moz_container_map_surface(container);
+    // Route input to parent wl_surface owned by Gtk+ so we get input
+    // events from Gtk+.
+    wl_region *region = wl_compositor_create_region(compositor);
+    wl_surface_set_input_region(container->surface, region);
+    wl_region_destroy(region);
+
+    wl_surface_set_buffer_scale(container->surface,
+                                moz_container_get_scale(container));
   }
 
   return container->surface;
 }
+
+struct wl_egl_window *moz_container_get_wl_egl_window(MozContainer *container) {
+  if (!container->eglwindow) {
+    wl_surface *surface = moz_container_get_wl_surface(container);
+    if (!surface) {
+      return nullptr;
+    }
+  }
+  return container->eglwindow;
+}
+
+gboolean moz_container_has_wl_egl_window(MozContainer *container) {
+  return container->eglwindow ? true : false;
+}
+
+gboolean moz_container_surface_needs_clear(MozContainer *container) {
+  gboolean state = container->surface_needs_clear;
+  container->surface_needs_clear = false;
+  return state;
+}
 #endif
diff -up thunderbird-60.5.0/widget/gtk/mozcontainer.h.wayland thunderbird-60.5.0/widget/gtk/mozcontainer.h
--- thunderbird-60.5.0/widget/gtk/mozcontainer.h.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/mozcontainer.h	2019-02-05 14:26:16.974316651 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -63,7 +63,6 @@ typedef struct _MozContainerClass MozCon
  * present in wayland-devel < 1.12
  */
 #ifdef MOZ_WAYLAND
-struct wl_subcompositor;
 struct wl_surface;
 struct wl_subsurface;
 #endif
@@ -73,9 +72,12 @@ struct _MozContainer {
   GList *children;
 
 #ifdef MOZ_WAYLAND
-  struct wl_subcompositor *subcompositor;
   struct wl_surface *surface;
   struct wl_subsurface *subsurface;
+  struct wl_egl_window *eglwindow;
+  struct wl_callback *frame_callback_handler;
+  gboolean surface_needs_clear;
+  gboolean ready_to_draw;
 #endif
 };
 
@@ -87,11 +89,13 @@ GType moz_container_get_type(void);
 GtkWidget *moz_container_new(void);
 void moz_container_put(MozContainer *container, GtkWidget *child_widget, gint x,
                        gint y);
-void moz_container_move(MozContainer *container, GtkWidget *child_widget,
-                        gint x, gint y, gint width, gint height);
 
 #ifdef MOZ_WAYLAND
 struct wl_surface *moz_container_get_wl_surface(MozContainer *container);
+struct wl_egl_window *moz_container_get_wl_egl_window(MozContainer *container);
+
+gboolean moz_container_has_wl_egl_window(MozContainer *container);
+gboolean moz_container_surface_needs_clear(MozContainer *container);
 #endif
 
 #endif /* __MOZ_CONTAINER_H__ */
diff -up thunderbird-60.5.0/widget/gtk/mozgtk/mozgtk.c.wayland thunderbird-60.5.0/widget/gtk/mozgtk/mozgtk.c
--- thunderbird-60.5.0/widget/gtk/mozgtk/mozgtk.c.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/mozgtk/mozgtk.c	2019-02-05 14:26:16.974316651 +0100
@@ -26,6 +26,7 @@ STUB(gdk_display_sync)
 STUB(gdk_display_warp_pointer)
 STUB(gdk_drag_context_get_actions)
 STUB(gdk_drag_context_get_dest_window)
+STUB(gdk_drag_context_get_source_window)
 STUB(gdk_drag_context_list_targets)
 STUB(gdk_drag_status)
 STUB(gdk_error_trap_pop)
@@ -55,6 +56,7 @@ STUB(gdk_pointer_grab)
 STUB(gdk_pointer_ungrab)
 STUB(gdk_property_change)
 STUB(gdk_property_get)
+STUB(gdk_property_delete)
 STUB(gdk_screen_get_default)
 STUB(gdk_screen_get_display)
 STUB(gdk_screen_get_font_options)
@@ -136,6 +138,8 @@ STUB(gdk_x11_get_xatom_by_name)
 STUB(gdk_x11_get_xatom_by_name_for_display)
 STUB(gdk_x11_lookup_xdisplay)
 STUB(gdk_x11_screen_get_xscreen)
+STUB(gdk_x11_screen_get_screen_number)
+STUB(gdk_x11_screen_lookup_visual)
 STUB(gdk_x11_screen_supports_net_wm_hint)
 STUB(gdk_x11_visual_get_xvisual)
 STUB(gdk_x11_window_foreign_new_for_display)
@@ -267,6 +271,7 @@ STUB(gtk_im_context_set_client_window)
 STUB(gtk_im_context_set_cursor_location)
 STUB(gtk_im_context_set_surrounding)
 STUB(gtk_im_context_simple_new)
+STUB(gtk_im_multicontext_get_context_id)
 STUB(gtk_im_multicontext_get_type)
 STUB(gtk_im_multicontext_new)
 STUB(gtk_info_bar_get_type)
@@ -411,6 +416,7 @@ STUB(gtk_table_get_type)
 STUB(gtk_table_new)
 STUB(gtk_target_list_add)
 STUB(gtk_target_list_add_image_targets)
+STUB(gtk_target_list_add_text_targets)
 STUB(gtk_target_list_new)
 STUB(gtk_target_list_unref)
 STUB(gtk_targets_include_image)
@@ -491,6 +497,7 @@ STUB(gtk_widget_unrealize)
 STUB(gtk_window_deiconify)
 STUB(gtk_window_fullscreen)
 STUB(gtk_window_get_group)
+STUB(gtk_window_get_modal)
 STUB(gtk_window_get_transient_for)
 STUB(gtk_window_get_type)
 STUB(gtk_window_get_type_hint)
diff -up thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.c.wayland thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.c
--- thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.c.wayland	2019-01-22 20:44:02.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.c	2019-02-05 14:26:16.974316651 +0100
@@ -1,14 +1,23 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include <stdlib.h>
 #include "mozilla/Types.h"
 #include <gtk/gtk.h>
+#include <gtk/gtkx.h>
 #include <gdk/gdkwayland.h>
 
+union wl_argument;
+
+/* Those strucures are just placeholders and will be replaced by
+ * real symbols from libwayland during run-time linking. We need to make
+ * them explicitly visible.
+ */
+#pragma GCC visibility push(default)
 const struct wl_interface wl_buffer_interface;
 const struct wl_interface wl_callback_interface;
 const struct wl_interface wl_data_device_interface;
@@ -22,6 +31,7 @@ const struct wl_interface wl_seat_interf
 const struct wl_interface wl_surface_interface;
 const struct wl_interface wl_subsurface_interface;
 const struct wl_interface wl_subcompositor_interface;
+#pragma GCC visibility pop
 
 MOZ_EXPORT void wl_event_queue_destroy(struct wl_event_queue *queue) {}
 
@@ -75,6 +85,10 @@ MOZ_EXPORT const void *wl_proxy_get_list
   return NULL;
 }
 
+typedef int (*wl_dispatcher_func_t)(const void *, void *, uint32_t,
+                                    const struct wl_message *,
+                                    union wl_argument *);
+
 MOZ_EXPORT int wl_proxy_add_dispatcher(struct wl_proxy *proxy,
                                        wl_dispatcher_func_t dispatcher_func,
                                        const void *dispatcher_data,
@@ -160,3 +174,13 @@ MOZ_EXPORT void wl_display_cancel_read(s
 MOZ_EXPORT int wl_display_read_events(struct wl_display *display) { return -1; }
 
 MOZ_EXPORT void wl_log_set_handler_client(wl_log_func_t handler) {}
+
+MOZ_EXPORT struct wl_egl_window *wl_egl_window_create(
+    struct wl_surface *surface, int width, int height) {
+  return NULL;
+}
+
+MOZ_EXPORT void wl_egl_window_destroy(struct wl_egl_window *egl_window) {}
+
+MOZ_EXPORT void wl_egl_window_resize(struct wl_egl_window *egl_window,
+                                     int width, int height, int dx, int dy) {}
diff -up thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.h.wayland thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.h
--- thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.h.wayland	2019-02-05 14:26:16.975316648 +0100
+++ thunderbird-60.5.0/widget/gtk/mozwayland/mozwayland.h	2019-02-05 14:26:16.975316648 +0100
@@ -0,0 +1,115 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Wayland compatibility header, it makes Firefox build with
+   wayland-1.2 and Gtk+ 3.10.
+*/
+
+#ifndef __MozWayland_h_
+#define __MozWayland_h_
+
+#include "mozilla/Types.h"
+#include <gtk/gtk.h>
+#include <gdk/gdkwayland.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MOZ_EXPORT int wl_display_roundtrip_queue(struct wl_display *display,
+                                          struct wl_event_queue *queue);
+MOZ_EXPORT uint32_t wl_proxy_get_version(struct wl_proxy *proxy);
+MOZ_EXPORT struct wl_proxy *wl_proxy_marshal_constructor(
+    struct wl_proxy *proxy, uint32_t opcode,
+    const struct wl_interface *interface, ...);
+
+/* We need implement some missing functions from wayland-client-protocol.h
+ */
+#ifndef WL_DATA_DEVICE_MANAGER_DND_ACTION_ENUM
+enum wl_data_device_manager_dnd_action {
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE = 0,
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY = 1,
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE = 2,
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK = 4
+};
+#endif
+
+#ifndef WL_DATA_OFFER_SET_ACTIONS
+#define WL_DATA_OFFER_SET_ACTIONS 4
+
+struct moz_wl_data_offer_listener {
+  void (*offer)(void *data, struct wl_data_offer *wl_data_offer,
+                const char *mime_type);
+  void (*source_actions)(void *data, struct wl_data_offer *wl_data_offer,
+                         uint32_t source_actions);
+  void (*action)(void *data, struct wl_data_offer *wl_data_offer,
+                 uint32_t dnd_action);
+};
+
+static inline void wl_data_offer_set_actions(
+    struct wl_data_offer *wl_data_offer, uint32_t dnd_actions,
+    uint32_t preferred_action) {
+  wl_proxy_marshal((struct wl_proxy *)wl_data_offer, WL_DATA_OFFER_SET_ACTIONS,
+                   dnd_actions, preferred_action);
+}
+#else
+typedef struct wl_data_offer_listener moz_wl_data_offer_listener;
+#endif
+
+#ifndef WL_SUBCOMPOSITOR_GET_SUBSURFACE
+#define WL_SUBCOMPOSITOR_GET_SUBSURFACE 1
+struct wl_subcompositor;
+
+// Emulate what mozilla header wrapper does - make the
+// wl_subcompositor_interface always visible.
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_subsurface_interface;
+extern const struct wl_interface wl_subcompositor_interface;
+#pragma GCC visibility pop
+
+#define WL_SUBSURFACE_DESTROY 0
+#define WL_SUBSURFACE_SET_POSITION 1
+#define WL_SUBSURFACE_PLACE_ABOVE 2
+#define WL_SUBSURFACE_PLACE_BELOW 3
+#define WL_SUBSURFACE_SET_SYNC 4
+#define WL_SUBSURFACE_SET_DESYNC 5
+
+static inline struct wl_subsurface *wl_subcompositor_get_subsurface(
+    struct wl_subcompositor *wl_subcompositor, struct wl_surface *surface,
+    struct wl_surface *parent) {
+  struct wl_proxy *id;
+
+  id = wl_proxy_marshal_constructor(
+      (struct wl_proxy *)wl_subcompositor, WL_SUBCOMPOSITOR_GET_SUBSURFACE,
+      &wl_subsurface_interface, NULL, surface, parent);
+
+  return (struct wl_subsurface *)id;
+}
+
+static inline void wl_subsurface_set_position(
+    struct wl_subsurface *wl_subsurface, int32_t x, int32_t y) {
+  wl_proxy_marshal((struct wl_proxy *)wl_subsurface, WL_SUBSURFACE_SET_POSITION,
+                   x, y);
+}
+
+static inline void wl_subsurface_set_desync(
+    struct wl_subsurface *wl_subsurface) {
+  wl_proxy_marshal((struct wl_proxy *)wl_subsurface, WL_SUBSURFACE_SET_DESYNC);
+}
+
+static inline void wl_subsurface_destroy(struct wl_subsurface *wl_subsurface) {
+  wl_proxy_marshal((struct wl_proxy *)wl_subsurface, WL_SUBSURFACE_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy *)wl_subsurface);
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MozWayland_h_ */
diff -up thunderbird-60.5.0/widget/gtk/nsClipboard.cpp.wayland thunderbird-60.5.0/widget/gtk/nsClipboard.cpp
--- thunderbird-60.5.0/widget/gtk/nsClipboard.cpp.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsClipboard.cpp	2019-02-05 14:26:16.975316648 +0100
@@ -72,7 +72,7 @@ nsClipboard::~nsClipboard() {
   }
 }
 
-NS_IMPL_ISUPPORTS(nsClipboard, nsIClipboard)
+NS_IMPL_ISUPPORTS(nsClipboard, nsIClipboard, nsIObserver)
 
 nsresult nsClipboard::Init(void) {
   GdkDisplay *display = gdk_display_get_default();
diff -up thunderbird-60.5.0/widget/gtk/nsClipboardWayland.cpp.wayland thunderbird-60.5.0/widget/gtk/nsClipboardWayland.cpp
--- thunderbird-60.5.0/widget/gtk/nsClipboardWayland.cpp.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsClipboardWayland.cpp	2019-02-05 14:26:16.975316648 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -20,9 +20,11 @@
 #include "nsImageToPixbuf.h"
 #include "nsStringStream.h"
 #include "nsIObserverService.h"
-#include "mozilla/Services.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/TimeStamp.h"
+#include "nsDragService.h"
+#include "mozwayland/mozwayland.h"
+#include "nsWaylandDisplay.h"
 
 #include "imgIContainer.h"
 
@@ -31,15 +33,43 @@
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
-#include <gtk/gtk.h>
-#include <gdk/gdkwayland.h>
 #include <errno.h>
 
-#include "wayland/gtk-primary-selection-client-protocol.h"
-
 const char *nsRetrievalContextWayland::sTextMimeTypes[TEXT_MIME_TYPES_NUM] = {
     "text/plain;charset=utf-8", "UTF8_STRING", "COMPOUND_TEXT"};
 
+static inline GdkDragAction wl_to_gdk_actions(uint32_t dnd_actions) {
+  GdkDragAction actions = GdkDragAction(0);
+
+  if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY)
+    actions = GdkDragAction(actions | GDK_ACTION_COPY);
+  if (dnd_actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
+    actions = GdkDragAction(actions | GDK_ACTION_MOVE);
+
+  return actions;
+}
+
+static inline uint32_t gdk_to_wl_actions(GdkDragAction action) {
+  uint32_t dnd_actions = 0;
+
+  if (action & (GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_PRIVATE))
+    dnd_actions |= WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
+  if (action & GDK_ACTION_MOVE)
+    dnd_actions |= WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE;
+
+  return dnd_actions;
+}
+
+static GtkWidget *get_gtk_widget_for_wl_surface(struct wl_surface *surface) {
+  GdkWindow *gdkParentWindow =
+      static_cast<GdkWindow *>(wl_surface_get_user_data(surface));
+
+  gpointer user_data = nullptr;
+  gdk_window_get_user_data(gdkParentWindow, &user_data);
+
+  return GTK_WIDGET(user_data);
+}
+
 void DataOffer::AddMIMEType(const char *aMimeType) {
   GdkAtom atom = gdk_atom_intern(aMimeType, FALSE);
   mTargetMIMETypes.AppendElement(atom);
@@ -98,7 +128,7 @@ char *DataOffer::GetData(wl_display *aDi
 
   GIOChannel *channel = g_io_channel_unix_new(pipe_fd[0]);
   GError *error = nullptr;
-  char *clipboardData;
+  char *clipboardData = nullptr;
 
   g_io_channel_set_encoding(channel, nullptr, &error);
   if (!error) {
@@ -138,31 +168,92 @@ bool WaylandDataOffer::RequestDataTransf
   return false;
 }
 
+void WaylandDataOffer::DragOfferAccept(const char *aMimeType, uint32_t aTime) {
+  wl_data_offer_accept(mWaylandDataOffer, aTime, aMimeType);
+}
+
+/* We follow logic of gdk_wayland_drag_context_commit_status()/gdkdnd-wayland.c
+ * here.
+ */
+void WaylandDataOffer::SetDragStatus(GdkDragAction aAction, uint32_t aTime) {
+  uint32_t dnd_actions = gdk_to_wl_actions(aAction);
+  uint32_t all_actions = WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY |
+                         WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE;
+
+  wl_data_offer_set_actions(mWaylandDataOffer, all_actions, dnd_actions);
+
+  /* Workaround Wayland D&D architecture here. To get the data_device_drop()
+     signal (which routes to nsDragService::GetData() call) we need to
+     accept at least one mime type before data_device_leave().
+
+     Real wl_data_offer_accept() for actualy requested data mime type is
+     called from nsDragService::GetData().
+  */
+  if (mTargetMIMETypes[0]) {
+    wl_data_offer_accept(mWaylandDataOffer, aTime,
+                         gdk_atom_name(mTargetMIMETypes[0]));
+  }
+}
+
+void WaylandDataOffer::SetSelectedDragAction(uint32_t aWaylandAction) {
+  mSelectedDragAction = aWaylandAction;
+}
+
+GdkDragAction WaylandDataOffer::GetSelectedDragAction() {
+  return wl_to_gdk_actions(mSelectedDragAction);
+}
+
+void WaylandDataOffer::SetAvailableDragActions(uint32_t aWaylandActions) {
+  mAvailableDragAction = aWaylandActions;
+}
+
+GdkDragAction WaylandDataOffer::GetAvailableDragActions() {
+  return wl_to_gdk_actions(mAvailableDragAction);
+}
+
 static void data_offer_offer(void *data, struct wl_data_offer *wl_data_offer,
                              const char *type) {
   auto *offer = static_cast<DataOffer *>(data);
   offer->AddMIMEType(type);
 }
 
+/* Advertise all available drag and drop actions from source.
+ * We don't use that but follow gdk_wayland_drag_context_commit_status()
+ * from gdkdnd-wayland.c here.
+ */
 static void data_offer_source_actions(void *data,
                                       struct wl_data_offer *wl_data_offer,
-                                      uint32_t source_actions) {}
+                                      uint32_t source_actions) {
+  auto *offer = static_cast<WaylandDataOffer *>(data);
+  offer->SetAvailableDragActions(source_actions);
+}
 
+/* Advertise recently selected drag and drop action by compositor, based
+ * on source actions and user choice (key modifiers, etc.).
+ */
 static void data_offer_action(void *data, struct wl_data_offer *wl_data_offer,
-                              uint32_t dnd_action) {}
+                              uint32_t dnd_action) {
+  auto *offer = static_cast<WaylandDataOffer *>(data);
+  offer->SetSelectedDragAction(dnd_action);
+}
 
 /* wl_data_offer callback description:
  *
  * data_offer_offer - Is called for each MIME type available at wl_data_offer.
- * data_offer_source_actions - Exposes all available D&D actions.
- * data_offer_action - Expose one actually selected D&D action.
+ * data_offer_source_actions - This event indicates the actions offered by
+ *                             the data source.
+ * data_offer_action - This event indicates the action selected by
+ *                     the compositor after matching the source/destination
+ *                     side actions.
  */
-static const struct wl_data_offer_listener data_offer_listener = {
+static const moz_wl_data_offer_listener data_offer_listener = {
     data_offer_offer, data_offer_source_actions, data_offer_action};
 
 WaylandDataOffer::WaylandDataOffer(wl_data_offer *aWaylandDataOffer)
     : mWaylandDataOffer(aWaylandDataOffer) {
-  wl_data_offer_add_listener(mWaylandDataOffer, &data_offer_listener, this);
+  wl_data_offer_add_listener(
+      mWaylandDataOffer, (struct wl_data_offer_listener *)&data_offer_listener,
+      this);
 }
 
 WaylandDataOffer::~WaylandDataOffer(void) {
@@ -207,20 +298,93 @@ PrimaryDataOffer::~PrimaryDataOffer(void
   }
 }
 
-void nsRetrievalContextWayland::RegisterDataOffer(
+NS_IMPL_ISUPPORTS(nsWaylandDragContext, nsISupports);
+
+nsWaylandDragContext::nsWaylandDragContext(WaylandDataOffer *aDataOffer,
+                                           wl_display *aDisplay)
+    : mDataOffer(aDataOffer),
+      mDisplay(aDisplay),
+      mTime(0),
+      mGtkWidget(nullptr),
+      mX(0),
+      mY(0) {}
+
+void nsWaylandDragContext::DropDataEnter(GtkWidget *aGtkWidget, uint32_t aTime,
+                                         nscoord aX, nscoord aY) {
+  mTime = aTime;
+  mGtkWidget = aGtkWidget;
+  mX = aX;
+  mY = aY;
+}
+
+void nsWaylandDragContext::DropMotion(uint32_t aTime, nscoord aX, nscoord aY) {
+  mTime = aTime;
+  mX = aX;
+  mY = aY;
+}
+
+void nsWaylandDragContext::GetLastDropInfo(uint32_t *aTime, nscoord *aX,
+                                           nscoord *aY) {
+  *aTime = mTime;
+  *aX = mX;
+  *aY = mY;
+}
+
+void nsWaylandDragContext::SetDragStatus(GdkDragAction aAction) {
+  mDataOffer->SetDragStatus(aAction, mTime);
+}
+
+GdkDragAction nsWaylandDragContext::GetSelectedDragAction() {
+  GdkDragAction gdkAction = mDataOffer->GetSelectedDragAction();
+
+  // We emulate gdk_drag_context_get_actions() here.
+  if (!gdkAction) {
+    gdkAction = mDataOffer->GetAvailableDragActions();
+  }
+
+  return gdkAction;
+}
+
+GList *nsWaylandDragContext::GetTargets() {
+  int targetNums;
+  GdkAtom *atoms = mDataOffer->GetTargets(&targetNums);
+
+  GList *targetList = nullptr;
+  for (int i = 0; i < targetNums; i++) {
+    targetList = g_list_append(targetList, GDK_ATOM_TO_POINTER(atoms[i]));
+  }
+
+  return targetList;
+}
+
+char *nsWaylandDragContext::GetData(const char *aMimeType,
+                                    uint32_t *aContentLength) {
+  mDataOffer->DragOfferAccept(aMimeType, mTime);
+  return mDataOffer->GetData(mDisplay, aMimeType, aContentLength);
+}
+
+void nsRetrievalContextWayland::RegisterNewDataOffer(
     wl_data_offer *aWaylandDataOffer) {
   DataOffer *dataOffer = static_cast<DataOffer *>(
       g_hash_table_lookup(mActiveOffers, aWaylandDataOffer));
+  MOZ_ASSERT(
+      dataOffer == nullptr,
+      "Registered WaylandDataOffer already exists. Wayland protocol error?");
+
   if (!dataOffer) {
     dataOffer = new WaylandDataOffer(aWaylandDataOffer);
     g_hash_table_insert(mActiveOffers, aWaylandDataOffer, dataOffer);
   }
 }
 
-void nsRetrievalContextWayland::RegisterDataOffer(
+void nsRetrievalContextWayland::RegisterNewDataOffer(
     gtk_primary_selection_offer *aPrimaryDataOffer) {
   DataOffer *dataOffer = static_cast<DataOffer *>(
       g_hash_table_lookup(mActiveOffers, aPrimaryDataOffer));
+  MOZ_ASSERT(
+      dataOffer == nullptr,
+      "Registered PrimaryDataOffer already exists. Wayland protocol error?");
+
   if (!dataOffer) {
     dataOffer = new PrimaryDataOffer(aPrimaryDataOffer);
     g_hash_table_insert(mActiveOffers, aPrimaryDataOffer, dataOffer);
@@ -229,21 +393,30 @@ void nsRetrievalContextWayland::Register
 
 void nsRetrievalContextWayland::SetClipboardDataOffer(
     wl_data_offer *aWaylandDataOffer) {
-  DataOffer *dataOffer = static_cast<DataOffer *>(
-      g_hash_table_lookup(mActiveOffers, aWaylandDataOffer));
-  NS_ASSERTION(dataOffer, "We're missing clipboard data offer!");
-  if (dataOffer) {
-    g_hash_table_remove(mActiveOffers, aWaylandDataOffer);
-    mClipboardOffer = dataOffer;
+  // Delete existing clipboard data offer
+  mClipboardOffer = nullptr;
+
+  // null aWaylandDataOffer indicates that our clipboard content
+  // is no longer valid and should be release.
+  if (aWaylandDataOffer != nullptr) {
+    DataOffer *dataOffer = static_cast<DataOffer *>(
+        g_hash_table_lookup(mActiveOffers, aWaylandDataOffer));
+    NS_ASSERTION(dataOffer, "We're missing stored clipboard data offer!");
+    if (dataOffer) {
+      g_hash_table_remove(mActiveOffers, aWaylandDataOffer);
+      mClipboardOffer = dataOffer;
+    }
   }
 }
 
 void nsRetrievalContextWayland::SetPrimaryDataOffer(
     gtk_primary_selection_offer *aPrimaryDataOffer) {
-  if (aPrimaryDataOffer == nullptr) {
-    // Release any primary offer we have.
-    mPrimaryOffer = nullptr;
-  } else {
+  // Release any primary offer we have.
+  mPrimaryOffer = nullptr;
+
+  // aPrimaryDataOffer can be null which means we lost
+  // the mouse selection.
+  if (aPrimaryDataOffer) {
     DataOffer *dataOffer = static_cast<DataOffer *>(
         g_hash_table_lookup(mActiveOffers, aPrimaryDataOffer));
     NS_ASSERTION(dataOffer, "We're missing primary data offer!");
@@ -254,9 +427,26 @@ void nsRetrievalContextWayland::SetPrima
   }
 }
 
-void nsRetrievalContextWayland::ClearDataOffers(void) {
-  if (mClipboardOffer) mClipboardOffer = nullptr;
-  if (mPrimaryOffer) mPrimaryOffer = nullptr;
+void nsRetrievalContextWayland::AddDragAndDropDataOffer(
+    wl_data_offer *aDropDataOffer) {
+  // Remove any existing D&D contexts.
+  mDragContext = nullptr;
+
+  WaylandDataOffer *dataOffer = static_cast<WaylandDataOffer *>(
+      g_hash_table_lookup(mActiveOffers, aDropDataOffer));
+  NS_ASSERTION(dataOffer, "We're missing drag and drop data offer!");
+  if (dataOffer) {
+    g_hash_table_remove(mActiveOffers, aDropDataOffer);
+    mDragContext = new nsWaylandDragContext(dataOffer, mDisplay->GetDisplay());
+  }
+}
+
+nsWaylandDragContext *nsRetrievalContextWayland::GetDragContext(void) {
+  return mDragContext;
+}
+
+void nsRetrievalContextWayland::ClearDragAndDropDataOffer(void) {
+  mDragContext = nullptr;
 }
 
 // We have a new fresh data content.
@@ -266,7 +456,7 @@ static void data_device_data_offer(void
                                    struct wl_data_offer *offer) {
   nsRetrievalContextWayland *context =
       static_cast<nsRetrievalContextWayland *>(data);
-  context->RegisterDataOffer(offer);
+  context->RegisterNewDataOffer(offer);
 }
 
 // The new fresh data content is clipboard.
@@ -281,15 +471,65 @@ static void data_device_selection(void *
 // The new fresh wayland data content is drag and drop.
 static void data_device_enter(void *data, struct wl_data_device *data_device,
                               uint32_t time, struct wl_surface *surface,
-                              int32_t x, int32_t y,
-                              struct wl_data_offer *offer) {}
+                              int32_t x_fixed, int32_t y_fixed,
+                              struct wl_data_offer *offer) {
+  nsRetrievalContextWayland *context =
+      static_cast<nsRetrievalContextWayland *>(data);
+  context->AddDragAndDropDataOffer(offer);
+
+  nsWaylandDragContext *dragContext = context->GetDragContext();
+
+  GtkWidget *gtkWidget = get_gtk_widget_for_wl_surface(surface);
+  if (!gtkWidget) {
+    NS_WARNING("DragAndDrop: Unable to get GtkWidget for wl_surface!");
+    return;
+  }
+
+  LOGDRAG(("nsWindow data_device_enter for GtkWidget %p\n", (void *)gtkWidget));
+
+  dragContext->DropDataEnter(gtkWidget, time, wl_fixed_to_int(x_fixed),
+                             wl_fixed_to_int(y_fixed));
+}
+
+static void data_device_leave(void *data, struct wl_data_device *data_device) {
+  nsRetrievalContextWayland *context =
+      static_cast<nsRetrievalContextWayland *>(data);
 
-static void data_device_leave(void *data, struct wl_data_device *data_device) {}
+  nsWaylandDragContext *dropContext = context->GetDragContext();
+  WindowDragLeaveHandler(dropContext->GetWidget());
+
+  context->ClearDragAndDropDataOffer();
+}
 
 static void data_device_motion(void *data, struct wl_data_device *data_device,
-                               uint32_t time, int32_t x, int32_t y) {}
+                               uint32_t time, int32_t x_fixed,
+                               int32_t y_fixed) {
+  nsRetrievalContextWayland *context =
+      static_cast<nsRetrievalContextWayland *>(data);
+
+  nsWaylandDragContext *dropContext = context->GetDragContext();
 
-static void data_device_drop(void *data, struct wl_data_device *data_device) {}
+  nscoord x = wl_fixed_to_int(x_fixed);
+  nscoord y = wl_fixed_to_int(y_fixed);
+  dropContext->DropMotion(time, x, y);
+
+  WindowDragMotionHandler(dropContext->GetWidget(), nullptr, dropContext, x, y,
+                          time);
+}
+
+static void data_device_drop(void *data, struct wl_data_device *data_device) {
+  nsRetrievalContextWayland *context =
+      static_cast<nsRetrievalContextWayland *>(data);
+
+  nsWaylandDragContext *dropContext = context->GetDragContext();
+
+  uint32_t time;
+  nscoord x, y;
+  dropContext->GetLastDropInfo(&time, &x, &y);
+
+  WindowDragDropHandler(dropContext->GetWidget(), nullptr, dropContext, x, y,
+                        time);
+}
 
 /* wl_data_device callback description:
  *
@@ -323,7 +563,7 @@ static void primary_selection_data_offer
   // create and add listener
   nsRetrievalContextWayland *context =
       static_cast<nsRetrievalContextWayland *>(data);
-  context->RegisterDataOffer(gtk_primary_offer);
+  context->RegisterNewDataOffer(gtk_primary_offer);
 }
 
 static void primary_selection_selection(
@@ -335,6 +575,19 @@ static void primary_selection_selection(
   context->SetPrimaryDataOffer(gtk_primary_offer);
 }
 
+/* gtk_primary_selection_device callback description:
+ *
+ * primary_selection_data_offer - It's called when there's a new
+ *                          gtk_primary_selection_offer available.  We need to
+ *                          attach gtk_primary_selection_offer_listener to it
+ *                          to get available MIME types.
+ *
+ * primary_selection_selection - It's called when the new
+ *                          gtk_primary_selection_offer is a primary selection
+ *                          content. It can be also called with
+ *                          gtk_primary_selection_offer = null which means
+ *                          there's no primary selection.
+ */
 static const struct gtk_primary_selection_device_listener
     primary_selection_device_listener = {
         primary_selection_data_offer,
@@ -342,149 +595,29 @@ static const struct gtk_primary_selectio
 };
 
 bool nsRetrievalContextWayland::HasSelectionSupport(void) {
-  return mPrimarySelectionDataDeviceManager != nullptr;
-}
-
-static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
-                                   uint32_t format, int fd, uint32_t size) {}
-
-static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
-                                  uint32_t serial, struct wl_surface *surface,
-                                  struct wl_array *keys) {}
-
-static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
-                                  uint32_t serial, struct wl_surface *surface) {
-  // We lost focus so our clipboard data are outdated
-  nsRetrievalContextWayland *context =
-      static_cast<nsRetrievalContextWayland *>(data);
-
-  context->ClearDataOffers();
+  return mDisplay->GetPrimarySelectionDeviceManager() != nullptr;
 }
 
-static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
-                                uint32_t serial, uint32_t time, uint32_t key,
-                                uint32_t state) {}
-
-static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
-                                      uint32_t serial, uint32_t mods_depressed,
-                                      uint32_t mods_latched,
-                                      uint32_t mods_locked, uint32_t group) {}
-
-static const struct wl_keyboard_listener keyboard_listener = {
-    keyboard_handle_keymap, keyboard_handle_enter,     keyboard_handle_leave,
-    keyboard_handle_key,    keyboard_handle_modifiers,
-};
-
-void nsRetrievalContextWayland::ConfigureKeyboard(wl_seat_capability caps) {
-  // ConfigureKeyboard() is called when wl_seat configuration is changed.
-  // We look for the keyboard only, get it when is't available and release it
-  // when it's lost (we don't have focus for instance).
-  if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
-    mKeyboard = wl_seat_get_keyboard(mSeat);
-    wl_keyboard_add_listener(mKeyboard, &keyboard_listener, this);
-  } else if (mKeyboard && !(caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
-    wl_keyboard_destroy(mKeyboard);
-    mKeyboard = nullptr;
-  }
-}
-
-static void seat_handle_capabilities(void *data, struct wl_seat *seat,
-                                     unsigned int caps) {
-  nsRetrievalContextWayland *context =
-      static_cast<nsRetrievalContextWayland *>(data);
-  context->ConfigureKeyboard((wl_seat_capability)caps);
-}
-
-static const struct wl_seat_listener seat_listener = {
-    seat_handle_capabilities,
-};
-
-void nsRetrievalContextWayland::InitDataDeviceManager(wl_registry *registry,
-                                                      uint32_t id,
-                                                      uint32_t version) {
-  int data_device_manager_version = MIN(version, 3);
-  mDataDeviceManager = (wl_data_device_manager *)wl_registry_bind(
-      registry, id, &wl_data_device_manager_interface,
-      data_device_manager_version);
-}
-
-void nsRetrievalContextWayland::InitPrimarySelectionDataDeviceManager(
-    wl_registry *registry, uint32_t id) {
-  mPrimarySelectionDataDeviceManager =
-      (gtk_primary_selection_device_manager *)wl_registry_bind(
-          registry, id, &gtk_primary_selection_device_manager_interface, 1);
-}
-
-void nsRetrievalContextWayland::InitSeat(wl_registry *registry, uint32_t id,
-                                         uint32_t version, void *data) {
-  mSeat = (wl_seat *)wl_registry_bind(registry, id, &wl_seat_interface, 1);
-  wl_seat_add_listener(mSeat, &seat_listener, data);
-}
-
-static void gdk_registry_handle_global(void *data, struct wl_registry *registry,
-                                       uint32_t id, const char *interface,
-                                       uint32_t version) {
-  nsRetrievalContextWayland *context =
-      static_cast<nsRetrievalContextWayland *>(data);
-
-  if (strcmp(interface, "wl_data_device_manager") == 0) {
-    context->InitDataDeviceManager(registry, id, version);
-  } else if (strcmp(interface, "wl_seat") == 0) {
-    context->InitSeat(registry, id, version, data);
-  } else if (strcmp(interface, "gtk_primary_selection_device_manager") == 0) {
-    context->InitPrimarySelectionDataDeviceManager(registry, id);
-  }
-}
-
-static void gdk_registry_handle_global_remove(void *data,
-                                              struct wl_registry *registry,
-                                              uint32_t id) {}
-
-static const struct wl_registry_listener clipboard_registry_listener = {
-    gdk_registry_handle_global, gdk_registry_handle_global_remove};
-
 nsRetrievalContextWayland::nsRetrievalContextWayland(void)
     : mInitialized(false),
-      mSeat(nullptr),
-      mDataDeviceManager(nullptr),
-      mPrimarySelectionDataDeviceManager(nullptr),
-      mKeyboard(nullptr),
+      mDisplay(WaylandDisplayGet()),
       mActiveOffers(g_hash_table_new(NULL, NULL)),
       mClipboardOffer(nullptr),
       mPrimaryOffer(nullptr),
+      mDragContext(nullptr),
       mClipboardRequestNumber(0),
       mClipboardData(nullptr),
       mClipboardDataLength(0) {
-  // Available as of GTK 3.8+
-  static auto sGdkWaylandDisplayGetWlDisplay = (wl_display * (*)(GdkDisplay *))
-      dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_display");
-
-  mDisplay = sGdkWaylandDisplayGetWlDisplay(gdk_display_get_default());
-  wl_registry_add_listener(wl_display_get_registry(mDisplay),
-                           &clipboard_registry_listener, this);
-  // Call wl_display_roundtrip() twice to make sure all
-  // callbacks are processed.
-  wl_display_roundtrip(mDisplay);
-  wl_display_roundtrip(mDisplay);
-
-  // mSeat/mDataDeviceManager should be set now by
-  // gdk_registry_handle_global() as a response to
-  // wl_registry_add_listener() call.
-  if (!mDataDeviceManager || !mSeat) return;
-
-  wl_data_device *dataDevice =
-      wl_data_device_manager_get_data_device(mDataDeviceManager, mSeat);
+  wl_data_device *dataDevice = wl_data_device_manager_get_data_device(
+      mDisplay->GetDataDeviceManager(), mDisplay->GetSeat());
   wl_data_device_add_listener(dataDevice, &data_device_listener, this);
-  // We have to call wl_display_roundtrip() twice otherwise data_offer_listener
-  // may not be processed because it's called from data_device_data_offer
-  // callback.
-  wl_display_roundtrip(mDisplay);
-  wl_display_roundtrip(mDisplay);
 
-  if (mPrimarySelectionDataDeviceManager) {
+  gtk_primary_selection_device_manager *manager =
+      mDisplay->GetPrimarySelectionDeviceManager();
+  if (manager) {
     gtk_primary_selection_device *primaryDataDevice =
-        gtk_primary_selection_device_manager_get_device(
-            mPrimarySelectionDataDeviceManager, mSeat);
+        gtk_primary_selection_device_manager_get_device(manager,
+                                                        mDisplay->GetSeat());
     gtk_primary_selection_device_add_listener(
         primaryDataDevice, &primary_selection_device_listener, this);
   }
@@ -492,8 +625,21 @@ nsRetrievalContextWayland::nsRetrievalCo
   mInitialized = true;
 }
 
+static gboolean offer_hash_remove(gpointer wl_offer, gpointer aDataOffer,
+                                  gpointer user_data) {
+#ifdef DEBUG
+  nsPrintfCString msg("nsRetrievalContextWayland(): leaked nsDataOffer %p\n",
+                      aDataOffer);
+  NS_WARNING(msg.get());
+#endif
+  delete static_cast<DataOffer *>(aDataOffer);
+  return true;
+}
+
 nsRetrievalContextWayland::~nsRetrievalContextWayland(void) {
+  g_hash_table_foreach_remove(mActiveOffers, offer_hash_remove, nullptr);
   g_hash_table_destroy(mActiveOffers);
+  WaylandDisplayRelease(mDisplay);
 }
 
 GdkAtom *nsRetrievalContextWayland::GetTargets(int32_t aWhichClipboard,
@@ -533,12 +679,14 @@ static void wayland_clipboard_contents_r
 void nsRetrievalContextWayland::TransferFastTrackClipboard(
     int aClipboardRequestNumber, GtkSelectionData *aSelectionData) {
   if (mClipboardRequestNumber == aClipboardRequestNumber) {
-    mClipboardDataLength = gtk_selection_data_get_length(aSelectionData);
-    if (mClipboardDataLength > 0) {
+    int dataLength = gtk_selection_data_get_length(aSelectionData);
+    if (dataLength > 0) {
+      mClipboardDataLength = dataLength;
       mClipboardData = reinterpret_cast<char *>(
-          g_malloc(sizeof(char) * mClipboardDataLength));
+          g_malloc(sizeof(char) * (mClipboardDataLength + 1)));
       memcpy(mClipboardData, gtk_selection_data_get_data(aSelectionData),
              sizeof(char) * mClipboardDataLength);
+      mClipboardData[mClipboardDataLength] = '\0';
     }
   } else {
     NS_WARNING("Received obsoleted clipboard data!");
@@ -572,8 +720,8 @@ const char *nsRetrievalContextWayland::G
       mClipboardData = nullptr;
       mClipboardDataLength = 0;
     } else {
-      mClipboardData =
-          dataOffer->GetData(mDisplay, aMimeType, &mClipboardDataLength);
+      mClipboardData = dataOffer->GetData(mDisplay->GetDisplay(), aMimeType,
+                                          &mClipboardDataLength);
     }
   }
 
@@ -588,7 +736,7 @@ const char *nsRetrievalContextWayland::G
       (selection == GDK_SELECTION_PRIMARY) ? mPrimaryOffer : mClipboardOffer;
   if (!dataOffer) return nullptr;
 
-  for (unsigned int i = 0; i < sizeof(sTextMimeTypes); i++) {
+  for (unsigned int i = 0; i < TEXT_MIME_TYPES_NUM; i++) {
     if (dataOffer->HasTarget(sTextMimeTypes[i])) {
       uint32_t unused;
       return GetClipboardData(sTextMimeTypes[i], aWhichClipboard, &unused);
diff -up thunderbird-60.5.0/widget/gtk/nsClipboardWayland.h.wayland thunderbird-60.5.0/widget/gtk/nsClipboardWayland.h
--- thunderbird-60.5.0/widget/gtk/nsClipboardWayland.h.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsClipboardWayland.h	2019-02-05 14:26:16.975316648 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -9,6 +9,7 @@
 #define __nsClipboardWayland_h_
 
 #include "nsIClipboard.h"
+#include "mozwayland/mozwayland.h"
 #include "wayland/gtk-primary-selection-client-protocol.h"
 
 #include <gtk/gtk.h>
@@ -32,31 +33,75 @@ class DataOffer {
  private:
   virtual bool RequestDataTransfer(const char* aMimeType, int fd) = 0;
 
+ protected:
   nsTArray<GdkAtom> mTargetMIMETypes;
 };
 
 class WaylandDataOffer : public DataOffer {
  public:
-  WaylandDataOffer(wl_data_offer* aWaylandDataOffer);
+  explicit WaylandDataOffer(wl_data_offer* aWaylandDataOffer);
+
+  void DragOfferAccept(const char* aMimeType, uint32_t aTime);
+  void SetDragStatus(GdkDragAction aAction, uint32_t aTime);
+
+  GdkDragAction GetSelectedDragAction();
+  void SetSelectedDragAction(uint32_t aWaylandAction);
+
+  void SetAvailableDragActions(uint32_t aWaylandActions);
+  GdkDragAction GetAvailableDragActions();
 
- private:
   virtual ~WaylandDataOffer();
+
+ private:
   bool RequestDataTransfer(const char* aMimeType, int fd) override;
 
   wl_data_offer* mWaylandDataOffer;
+  uint32_t mSelectedDragAction;
+  uint32_t mAvailableDragAction;
 };
 
 class PrimaryDataOffer : public DataOffer {
  public:
-  PrimaryDataOffer(gtk_primary_selection_offer* aPrimaryDataOffer);
+  explicit PrimaryDataOffer(gtk_primary_selection_offer* aPrimaryDataOffer);
+  void SetAvailableDragActions(uint32_t aWaylandActions){};
 
- private:
   virtual ~PrimaryDataOffer();
+
+ private:
   bool RequestDataTransfer(const char* aMimeType, int fd) override;
 
   gtk_primary_selection_offer* mPrimaryDataOffer;
 };
 
+class nsWaylandDragContext : public nsISupports {
+  NS_DECL_ISUPPORTS
+
+ public:
+  nsWaylandDragContext(WaylandDataOffer* aWaylandDataOffer,
+                       wl_display* aDisplay);
+
+  void DropDataEnter(GtkWidget* aGtkWidget, uint32_t aTime, nscoord aX,
+                     nscoord aY);
+  void DropMotion(uint32_t aTime, nscoord aX, nscoord aY);
+  void GetLastDropInfo(uint32_t* aTime, nscoord* aX, nscoord* aY);
+
+  void SetDragStatus(GdkDragAction action);
+  GdkDragAction GetSelectedDragAction();
+
+  GtkWidget* GetWidget() { return mGtkWidget; }
+  GList* GetTargets();
+  char* GetData(const char* aMimeType, uint32_t* aContentLength);
+
+ private:
+  virtual ~nsWaylandDragContext(){};
+
+  nsAutoPtr<WaylandDataOffer> mDataOffer;
+  wl_display* mDisplay;
+  uint32_t mTime;
+  GtkWidget* mGtkWidget;
+  nscoord mX, mY;
+};
+
 class nsRetrievalContextWayland : public nsRetrievalContext {
  public:
   nsRetrievalContextWayland();
@@ -71,38 +116,30 @@ class nsRetrievalContextWayland : public
                               int* aTargetNum) override;
   virtual bool HasSelectionSupport(void) override;
 
-  void RegisterDataOffer(wl_data_offer* aWaylandDataOffer);
-  void RegisterDataOffer(gtk_primary_selection_offer* aPrimaryDataOffer);
+  void RegisterNewDataOffer(wl_data_offer* aWaylandDataOffer);
+  void RegisterNewDataOffer(gtk_primary_selection_offer* aPrimaryDataOffer);
 
   void SetClipboardDataOffer(wl_data_offer* aWaylandDataOffer);
   void SetPrimaryDataOffer(gtk_primary_selection_offer* aPrimaryDataOffer);
+  void AddDragAndDropDataOffer(wl_data_offer* aWaylandDataOffer);
+  nsWaylandDragContext* GetDragContext();
 
-  void ClearDataOffers();
+  void ClearDragAndDropDataOffer();
 
-  void ConfigureKeyboard(wl_seat_capability caps);
   void TransferFastTrackClipboard(int aClipboardRequestNumber,
                                   GtkSelectionData* aSelectionData);
 
-  void InitDataDeviceManager(wl_registry* registry, uint32_t id,
-                             uint32_t version);
-  void InitPrimarySelectionDataDeviceManager(wl_registry* registry,
-                                             uint32_t id);
-  void InitSeat(wl_registry* registry, uint32_t id, uint32_t version,
-                void* data);
   virtual ~nsRetrievalContextWayland() override;
 
  private:
   bool mInitialized;
-  wl_display* mDisplay;
-  wl_seat* mSeat;
-  wl_data_device_manager* mDataDeviceManager;
-  gtk_primary_selection_device_manager* mPrimarySelectionDataDeviceManager;
-  wl_keyboard* mKeyboard;
+  nsWaylandDisplay* mDisplay;
 
   // Data offers provided by Wayland data device
   GHashTable* mActiveOffers;
   nsAutoPtr<DataOffer> mClipboardOffer;
   nsAutoPtr<DataOffer> mPrimaryOffer;
+  RefPtr<nsWaylandDragContext> mDragContext;
 
   int mClipboardRequestNumber;
   char* mClipboardData;
diff -up thunderbird-60.5.0/widget/gtk/nsDragService.cpp.wayland thunderbird-60.5.0/widget/gtk/nsDragService.cpp
--- thunderbird-60.5.0/widget/gtk/nsDragService.cpp.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsDragService.cpp	2019-02-05 14:26:16.976316645 +0100
@@ -1,5 +1,5 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* vim: set ts=4 et sw=4 tw=80: */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
@@ -9,6 +9,7 @@
 #include "nsIObserverService.h"
 #include "nsWidgetsCID.h"
 #include "nsWindow.h"
+#include "nsSystemInfo.h"
 #include "nsIServiceManager.h"
 #include "nsXPCOM.h"
 #include "nsISupportsPrimitives.h"
@@ -34,7 +35,6 @@
 #include "nsPresContext.h"
 #include "nsIContent.h"
 #include "nsIDocument.h"
-#include "nsISelection.h"
 #include "nsViewManager.h"
 #include "nsIFrame.h"
 #include "nsGtkUtils.h"
@@ -43,10 +43,15 @@
 #include "gfxPlatform.h"
 #include "ScreenHelperGTK.h"
 #include "nsArrayUtils.h"
+#ifdef MOZ_WAYLAND
+#include "nsClipboardWayland.h"
+#endif
 
 using namespace mozilla;
 using namespace mozilla::gfx;
 
+#define NS_SYSTEMINFO_CONTRACTID "@mozilla.org/system-info;1"
+
 // This sets how opaque the drag image is
 #define DRAG_IMAGE_ALPHA_LEVEL 0.5
 
@@ -68,6 +73,7 @@ static const char gMimeListType[] = "app
 static const char gMozUrlType[] = "_NETSCAPE_URL";
 static const char gTextUriListType[] = "text/uri-list";
 static const char gTextPlainUTF8Type[] = "text/plain;charset=utf-8";
+static const char gXdndDirectSaveType[] = "XdndDirectSave0";
 
 static void invisibleSourceDragBegin(GtkWidget *aWidget,
                                      GdkDragContext *aContext, gpointer aData);
@@ -85,7 +91,15 @@ static void invisibleSourceDragDataGet(G
                                        guint aInfo, guint32 aTime,
                                        gpointer aData);
 
-nsDragService::nsDragService() : mScheduledTask(eDragTaskNone), mTaskSource(0) {
+nsDragService::nsDragService()
+    : mScheduledTask(eDragTaskNone),
+      mTaskSource(0)
+#ifdef MOZ_WAYLAND
+      ,
+      mPendingWaylandDragContext(nullptr),
+      mTargetWaylandDragContext(nullptr)
+#endif
+{
   // We have to destroy the hidden widget before the event loop stops
   // running.
   nsCOMPtr<nsIObserverService> obsServ =
@@ -159,7 +173,7 @@ nsDragService::Observe(nsISupports *aSub
     }
     TargetResetData();
   } else {
-    NS_NOTREACHED("unexpected topic");
+    MOZ_ASSERT_UNREACHABLE("unexpected topic");
     return NS_ERROR_UNEXPECTED;
   }
 
@@ -457,6 +471,9 @@ nsDragService::EndDragSession(bool aDone
 
   // We're done with the drag context.
   mTargetDragContextForRemote = nullptr;
+#ifdef MOZ_WAYLAND
+  mTargetWaylandDragContextForRemote = nullptr;
+#endif
 
   return nsBaseDragService::EndDragSession(aDoneDrag, aKeyModifiers);
 }
@@ -550,6 +567,14 @@ nsDragService::GetNumDropItems(uint32_t
     return NS_OK;
   }
 
+#ifdef MOZ_WAYLAND
+  // TODO: Wayland implementation of text/uri-list.
+  if (!mTargetDragContext) {
+    *aNumItems = 1;
+    return NS_OK;
+  }
+#endif
+
   bool isList = IsTargetContextList();
   if (isList)
     mSourceDataItems->GetLength(aNumItems);
@@ -907,9 +932,18 @@ nsDragService::IsDataFlavorSupported(con
   }
 
   // check the target context vs. this flavor, one at a time
-  GList *tmp;
-  for (tmp = gdk_drag_context_list_targets(mTargetDragContext); tmp;
-       tmp = tmp->next) {
+  GList *tmp = nullptr;
+  if (mTargetDragContext) {
+    tmp = gdk_drag_context_list_targets(mTargetDragContext);
+  }
+#ifdef MOZ_WAYLAND
+  else if (mTargetWaylandDragContext) {
+    tmp = mTargetWaylandDragContext->GetTargets();
+  }
+  GList *tmp_head = tmp;
+#endif
+
+  for (; tmp; tmp = tmp->next) {
     /* Bug 331198 */
     GdkAtom atom = GDK_POINTER_TO_ATOM(tmp->data);
     gchar *name = nullptr;
@@ -946,6 +980,15 @@ nsDragService::IsDataFlavorSupported(con
     }
     g_free(name);
   }
+
+#ifdef MOZ_WAYLAND
+  // mTargetWaylandDragContext->GetTargets allocates the list
+  // so we need to free it here.
+  if (!mTargetDragContext && tmp_head) {
+    g_list_free(tmp_head);
+  }
+#endif
+
   return NS_OK;
 }
 
@@ -975,6 +1018,34 @@ void nsDragService::ReplyToDragMotion(Gd
   gdk_drag_status(aDragContext, action, mTargetTime);
 }
 
+#ifdef MOZ_WAYLAND
+void nsDragService::ReplyToDragMotion(nsWaylandDragContext *aDragContext) {
+  MOZ_LOG(sDragLm, LogLevel::Debug,
+          ("nsDragService::ReplyToDragMotion %d", mCanDrop));
+
+  GdkDragAction action = (GdkDragAction)0;
+  if (mCanDrop) {
+    // notify the dragger if we can drop
+    switch (mDragAction) {
+      case DRAGDROP_ACTION_COPY:
+        action = GDK_ACTION_COPY;
+        break;
+      case DRAGDROP_ACTION_LINK:
+        action = GDK_ACTION_LINK;
+        break;
+      case DRAGDROP_ACTION_NONE:
+        action = (GdkDragAction)0;
+        break;
+      default:
+        action = GDK_ACTION_MOVE;
+        break;
+    }
+  }
+
+  aDragContext->SetDragStatus(action);
+}
+#endif
+
 void nsDragService::TargetDataReceived(GtkWidget *aWidget,
                                        GdkDragContext *aContext, gint aX,
                                        gint aY,
@@ -999,6 +1070,11 @@ void nsDragService::TargetDataReceived(G
 bool nsDragService::IsTargetContextList(void) {
   bool retval = false;
 
+#ifdef MOZ_WAYLAND
+  // TODO: We need a wayland implementation here.
+  if (!mTargetDragContext) return retval;
+#endif
+
   // gMimeListType drags only work for drags within a single process. The
   // gtk_drag_get_source_widget() function will return nullptr if the source
   // of the drag is another app, so we use it to check if a gMimeListType
@@ -1032,17 +1108,27 @@ void nsDragService::GetTargetDragData(Gd
            mTargetDragContext.get()));
   // reset our target data areas
   TargetResetData();
-  gtk_drag_get_data(mTargetWidget, mTargetDragContext, aFlavor, mTargetTime);
 
-  MOZ_LOG(sDragLm, LogLevel::Debug, ("about to start inner iteration."));
-  PRTime entryTime = PR_Now();
-  while (!mTargetDragDataReceived && mDoingDrag) {
-    // check the number of iterations
-    MOZ_LOG(sDragLm, LogLevel::Debug, ("doing iteration...\n"));
-    PR_Sleep(20 * PR_TicksPerSecond() / 1000); /* sleep for 20 ms/iteration */
-    if (PR_Now() - entryTime > NS_DND_TIMEOUT) break;
-    gtk_main_iteration();
+  if (mTargetDragContext) {
+    gtk_drag_get_data(mTargetWidget, mTargetDragContext, aFlavor, mTargetTime);
+
+    MOZ_LOG(sDragLm, LogLevel::Debug, ("about to start inner iteration."));
+    PRTime entryTime = PR_Now();
+    while (!mTargetDragDataReceived && mDoingDrag) {
+      // check the number of iterations
+      MOZ_LOG(sDragLm, LogLevel::Debug, ("doing iteration...\n"));
+      PR_Sleep(20 * PR_TicksPerSecond() / 1000); /* sleep for 20 ms/iteration */
+      if (PR_Now() - entryTime > NS_DND_TIMEOUT) break;
+      gtk_main_iteration();
+    }
   }
+#ifdef MOZ_WAYLAND
+  else {
+    mTargetDragData = mTargetWaylandDragContext->GetData(gdk_atom_name(aFlavor),
+                                                         &mTargetDragDataLen);
+    mTargetDragDataReceived = true;
+  }
+#endif
   MOZ_LOG(sDragLm, LogLevel::Debug, ("finished inner iteration\n"));
 }
 
@@ -1218,6 +1304,10 @@ void nsDragService::SourceEndDragSession
   // this just releases the list of data items that we provide
   mSourceDataItems = nullptr;
 
+  // Remove this property, if it exists, to satisfy the Direct Save Protocol.
+  GdkAtom property = gdk_atom_intern(gXdndDirectSaveType, FALSE);
+  gdk_property_delete(gdk_drag_context_get_source_window(aContext), property);
+
   if (!mDoingDrag || mScheduledTask == eDragTaskSourceEnd)
     // EndDragSession() was already called on drop
     // or SourceEndDragSession on drag-failed
@@ -1276,7 +1366,7 @@ void nsDragService::SourceEndDragSession
   }
 
   // Schedule the appropriate drag end dom events.
-  Schedule(eDragTaskSourceEnd, nullptr, nullptr, LayoutDeviceIntPoint(), 0);
+  Schedule(eDragTaskSourceEnd, nullptr, nullptr, nullptr, LayoutDeviceIntPoint(), 0);
 }
 
 static void CreateUriList(nsIArray *items, gchar **text, gint *length) {
@@ -1585,11 +1675,11 @@ static void invisibleSourceDragEnd(GtkWi
 // Gecko drag events are in flight.  This helps event handlers that may not
 // expect nested events, while accessing an event's dataTransfer for example.
 
-gboolean nsDragService::ScheduleMotionEvent(nsWindow *aWindow,
-                                            GdkDragContext *aDragContext,
-                                            LayoutDeviceIntPoint aWindowPoint,
-                                            guint aTime) {
-  if (mScheduledTask == eDragTaskMotion) {
+gboolean nsDragService::ScheduleMotionEvent(
+    nsWindow *aWindow, GdkDragContext *aDragContext,
+    nsWaylandDragContext *aWaylandDragContext,
+    LayoutDeviceIntPoint aWindowPoint, guint aTime) {
+  if (aDragContext && mScheduledTask == eDragTaskMotion) {
     // The drag source has sent another motion message before we've
     // replied to the previous.  That shouldn't happen with Xdnd.  The
     // spec for Motif drags is less clear, but we'll just update the
@@ -1600,23 +1690,26 @@ gboolean nsDragService::ScheduleMotionEv
 
   // Returning TRUE means we'll reply with a status message, unless we first
   // get a leave.
-  return Schedule(eDragTaskMotion, aWindow, aDragContext, aWindowPoint, aTime);
+  return Schedule(eDragTaskMotion, aWindow, aDragContext, aWaylandDragContext,
+                  aWindowPoint, aTime);
 }
 
 void nsDragService::ScheduleLeaveEvent() {
   // We don't know at this stage whether a drop signal will immediately
   // follow.  If the drop signal gets sent it will happen before we return
   // to the main loop and the scheduled leave task will be replaced.
-  if (!Schedule(eDragTaskLeave, nullptr, nullptr, LayoutDeviceIntPoint(), 0)) {
+  if (!Schedule(eDragTaskLeave, nullptr, nullptr, nullptr,
+                LayoutDeviceIntPoint(), 0)) {
     NS_WARNING("Drag leave after drop");
   }
 }
 
-gboolean nsDragService::ScheduleDropEvent(nsWindow *aWindow,
-                                          GdkDragContext *aDragContext,
-                                          LayoutDeviceIntPoint aWindowPoint,
-                                          guint aTime) {
-  if (!Schedule(eDragTaskDrop, aWindow, aDragContext, aWindowPoint, aTime)) {
+gboolean nsDragService::ScheduleDropEvent(
+    nsWindow *aWindow, GdkDragContext *aDragContext,
+    nsWaylandDragContext *aWaylandDragContext,
+    LayoutDeviceIntPoint aWindowPoint, guint aTime) {
+  if (!Schedule(eDragTaskDrop, aWindow, aDragContext, aWaylandDragContext,
+                aWindowPoint, aTime)) {
     NS_WARNING("Additional drag drop ignored");
     return FALSE;
   }
@@ -1629,6 +1722,7 @@ gboolean nsDragService::ScheduleDropEven
 
 gboolean nsDragService::Schedule(DragTask aTask, nsWindow *aWindow,
                                  GdkDragContext *aDragContext,
+                                 nsWaylandDragContext *aWaylandDragContext,
                                  LayoutDeviceIntPoint aWindowPoint,
                                  guint aTime) {
   // If there is an existing leave or motion task scheduled, then that
@@ -1647,6 +1741,9 @@ gboolean nsDragService::Schedule(DragTas
   mScheduledTask = aTask;
   mPendingWindow = aWindow;
   mPendingDragContext = aDragContext;
+#ifdef MOZ_WAYLAND
+  mPendingWaylandDragContext = aWaylandDragContext;
+#endif
   mPendingWindowPoint = aWindowPoint;
   mPendingTime = aTime;
 
@@ -1717,6 +1814,9 @@ gboolean nsDragService::RunScheduledTask
   // succeeed.
   mTargetWidget = mTargetWindow->GetMozContainerWidget();
   mTargetDragContext.steal(mPendingDragContext);
+#ifdef MOZ_WAYLAND
+  mTargetWaylandDragContext = mPendingWaylandDragContext.forget();
+#endif
   mTargetTime = mPendingTime;
 
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#drag-and-drop-processing-model
@@ -1748,10 +1848,20 @@ gboolean nsDragService::RunScheduledTask
     if (task == eDragTaskMotion) {
       if (TakeDragEventDispatchedToChildProcess()) {
         mTargetDragContextForRemote = mTargetDragContext;
+#ifdef MOZ_WAYLAND
+        mTargetWaylandDragContextForRemote = mTargetWaylandDragContext;
+#endif
       } else {
         // Reply to tell the source whether we can drop and what
         // action would be taken.
-        ReplyToDragMotion(mTargetDragContext);
+        if (mTargetDragContext) {
+          ReplyToDragMotion(mTargetDragContext);
+        }
+#ifdef MOZ_WAYLAND
+        else if (mTargetWaylandDragContext) {
+          ReplyToDragMotion(mTargetWaylandDragContext);
+        }
+#endif
       }
     }
   }
@@ -1762,8 +1872,10 @@ gboolean nsDragService::RunScheduledTask
     // Perhaps we should set the del parameter to TRUE when the drag
     // action is move, but we don't know whether the data was successfully
     // transferred.
-    gtk_drag_finish(mTargetDragContext, success,
-                    /* del = */ FALSE, mTargetTime);
+    if (mTargetDragContext) {
+      gtk_drag_finish(mTargetDragContext, success,
+                      /* del = */ FALSE, mTargetTime);
+    }
 
     // This drag is over, so clear out our reference to the previous
     // window.
@@ -1776,6 +1888,9 @@ gboolean nsDragService::RunScheduledTask
   // We're done with the drag context.
   mTargetWidget = nullptr;
   mTargetDragContext = nullptr;
+#ifdef MOZ_WAYLAND
+  mTargetWaylandDragContext = nullptr;
+#endif
 
   // If we got another drag signal while running the sheduled task, that
   // must have happened while running a nested event loop.  Leave the task
@@ -1802,7 +1917,16 @@ void nsDragService::UpdateDragAction() {
 
   // default is to do nothing
   int action = nsIDragService::DRAGDROP_ACTION_NONE;
-  GdkDragAction gdkAction = gdk_drag_context_get_actions(mTargetDragContext);
+  GdkDragAction gdkAction = GDK_ACTION_DEFAULT;
+  if (mTargetDragContext) {
+    gdkAction = gdk_drag_context_get_actions(mTargetDragContext);
+  }
+#ifdef MOZ_WAYLAND
+  else if (mTargetWaylandDragContext) {
+    // We got the selected D&D action from compositor on Wayland.
+    gdkAction = mTargetWaylandDragContext->GetSelectedDragAction();
+  }
+#endif
 
   // set the default just in case nothing matches below
   if (gdkAction & GDK_ACTION_DEFAULT)
@@ -1830,6 +1954,12 @@ nsDragService::UpdateDragEffect() {
     ReplyToDragMotion(mTargetDragContextForRemote);
     mTargetDragContextForRemote = nullptr;
   }
+#ifdef MOZ_WAYLAND
+  else if (mTargetWaylandDragContextForRemote) {
+    ReplyToDragMotion(mTargetWaylandDragContextForRemote);
+    mTargetWaylandDragContextForRemote = nullptr;
+  }
+#endif
   return NS_OK;
 }
 
diff -up thunderbird-60.5.0/widget/gtk/nsDragService.h.wayland thunderbird-60.5.0/widget/gtk/nsDragService.h
--- thunderbird-60.5.0/widget/gtk/nsDragService.h.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsDragService.h	2019-02-05 14:26:16.976316645 +0100
@@ -1,5 +1,5 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* vim: set ts=4 et sw=4 tw=80: */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
@@ -14,6 +14,7 @@
 #include <gtk/gtk.h>
 
 class nsWindow;
+class nsWaylandDragContext;
 
 namespace mozilla {
 namespace gfx {
@@ -91,10 +92,12 @@ class nsDragService final : public nsBas
                           guint aInfo, guint32 aTime);
 
   gboolean ScheduleMotionEvent(nsWindow *aWindow, GdkDragContext *aDragContext,
+                               nsWaylandDragContext *aPendingWaylandDragContext,
                                mozilla::LayoutDeviceIntPoint aWindowPoint,
                                guint aTime);
   void ScheduleLeaveEvent();
   gboolean ScheduleDropEvent(nsWindow *aWindow, GdkDragContext *aDragContext,
+                             nsWaylandDragContext *aPendingWaylandDragContext,
                              mozilla::LayoutDeviceIntPoint aWindowPoint,
                              guint aTime);
 
@@ -111,6 +114,8 @@ class nsDragService final : public nsBas
   void SourceDataGet(GtkWidget *widget, GdkDragContext *context,
                      GtkSelectionData *selection_data, guint32 aTime);
 
+  void SourceBeginDrag(GdkDragContext *aContext);
+
   // set the drag icon during drag-begin
   void SetDragIcon(GdkDragContext *aContext);
 
@@ -144,6 +149,9 @@ class nsDragService final : public nsBas
   RefPtr<nsWindow> mPendingWindow;
   mozilla::LayoutDeviceIntPoint mPendingWindowPoint;
   nsCountedRef<GdkDragContext> mPendingDragContext;
+#ifdef MOZ_WAYLAND
+  RefPtr<nsWaylandDragContext> mPendingWaylandDragContext;
+#endif
   guint mPendingTime;
 
   // mTargetWindow and mTargetWindowPoint record the position of the last
@@ -155,9 +163,15 @@ class nsDragService final : public nsBas
   // motion or drop events.  mTime records the corresponding timestamp.
   nsCountedRef<GtkWidget> mTargetWidget;
   nsCountedRef<GdkDragContext> mTargetDragContext;
+#ifdef MOZ_WAYLAND
+  RefPtr<nsWaylandDragContext> mTargetWaylandDragContext;
+#endif
   // mTargetDragContextForRemote is set while waiting for a reply from
   // a child process.
   nsCountedRef<GdkDragContext> mTargetDragContextForRemote;
+#ifdef MOZ_WAYLAND
+  RefPtr<nsWaylandDragContext> mTargetWaylandDragContextForRemote;
+#endif
   guint mTargetTime;
 
   // is it OK to drop on us?
@@ -196,6 +210,7 @@ class nsDragService final : public nsBas
 
   gboolean Schedule(DragTask aTask, nsWindow *aWindow,
                     GdkDragContext *aDragContext,
+                    nsWaylandDragContext *aPendingWaylandDragContext,
                     mozilla::LayoutDeviceIntPoint aWindowPoint, guint aTime);
 
   // Callback for g_idle_add_full() to run mScheduledTask.
@@ -204,6 +219,9 @@ class nsDragService final : public nsBas
   void UpdateDragAction();
   void DispatchMotionEvents();
   void ReplyToDragMotion(GdkDragContext *aDragContext);
+#ifdef MOZ_WAYLAND
+  void ReplyToDragMotion(nsWaylandDragContext *aDragContext);
+#endif
   gboolean DispatchDropEvent();
   static uint32_t GetCurrentModifiers();
 };
diff -up thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.cpp.wayland thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.cpp
--- thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.cpp.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.cpp	2019-02-05 14:26:16.976316645 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -28,6 +28,10 @@
 #include "mozilla/MouseEvents.h"
 #include "mozilla/TextEvents.h"
 
+#ifdef MOZ_WAYLAND
+#include <sys/mman.h>
+#endif
+
 namespace mozilla {
 namespace widget {
 
@@ -200,7 +204,11 @@ void KeymapWrapper::Init() {
   mModifierKeys.Clear();
   memset(mModifierMasks, 0, sizeof(mModifierMasks));
 
-  if (GDK_IS_X11_DISPLAY(gdk_display_get_default())) InitBySystemSettings();
+  if (GDK_IS_X11_DISPLAY(gdk_display_get_default())) InitBySystemSettingsX11();
+#ifdef MOZ_WAYLAND
+  else
+    InitBySystemSettingsWayland();
+#endif
 
   gdk_window_add_filter(nullptr, FilterEvents, this);
 
@@ -276,9 +284,9 @@ void KeymapWrapper::InitXKBExtension() {
           ("%p InitXKBExtension, Succeeded", this));
 }
 
-void KeymapWrapper::InitBySystemSettings() {
+void KeymapWrapper::InitBySystemSettingsX11() {
   MOZ_LOG(gKeymapWrapperLog, LogLevel::Info,
-          ("%p InitBySystemSettings, mGdkKeymap=%p", this, mGdkKeymap));
+          ("%p InitBySystemSettingsX11, mGdkKeymap=%p", this, mGdkKeymap));
 
   Display* display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
 
@@ -439,6 +447,163 @@ void KeymapWrapper::InitBySystemSettings
   XFree(xkeymap);
 }
 
+#ifdef MOZ_WAYLAND
+void KeymapWrapper::SetModifierMask(xkb_keymap* aKeymap,
+                                    ModifierIndex aModifierIndex,
+                                    const char* aModifierName) {
+  static auto sXkbKeymapModGetIndex =
+      (xkb_mod_index_t(*)(struct xkb_keymap*, const char*))dlsym(
+          RTLD_DEFAULT, "xkb_keymap_mod_get_index");
+
+  xkb_mod_index_t index = sXkbKeymapModGetIndex(aKeymap, aModifierName);
+  if (index != XKB_MOD_INVALID) {
+    mModifierMasks[aModifierIndex] = (1 << index);
+  }
+}
+
+void KeymapWrapper::SetModifierMasks(xkb_keymap* aKeymap) {
+  KeymapWrapper* keymapWrapper = GetInstance();
+
+  // This mapping is derived from get_xkb_modifiers() at gdkkeys-wayland.c
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_NUM_LOCK, XKB_MOD_NAME_NUM);
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_ALT, XKB_MOD_NAME_ALT);
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_META, "Meta");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_SUPER, "Super");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_HYPER, "Hyper");
+
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_SCROLL_LOCK, "ScrollLock");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL3, "Level3");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL5, "Level5");
+
+  MOZ_LOG(gKeymapWrapperLog, LogLevel::Info,
+          ("%p KeymapWrapper::SetModifierMasks, CapsLock=0x%X, NumLock=0x%X, "
+           "ScrollLock=0x%X, Level3=0x%X, Level5=0x%X, "
+           "Shift=0x%X, Ctrl=0x%X, Alt=0x%X, Meta=0x%X, Super=0x%X, Hyper=0x%X",
+           keymapWrapper, keymapWrapper->GetModifierMask(CAPS_LOCK),
+           keymapWrapper->GetModifierMask(NUM_LOCK),
+           keymapWrapper->GetModifierMask(SCROLL_LOCK),
+           keymapWrapper->GetModifierMask(LEVEL3),
+           keymapWrapper->GetModifierMask(LEVEL5),
+           keymapWrapper->GetModifierMask(SHIFT),
+           keymapWrapper->GetModifierMask(CTRL),
+           keymapWrapper->GetModifierMask(ALT),
+           keymapWrapper->GetModifierMask(META),
+           keymapWrapper->GetModifierMask(SUPER),
+           keymapWrapper->GetModifierMask(HYPER)));
+}
+
+/* This keymap routine is derived from weston-2.0.0/clients/simple-im.c
+ */
+static void keyboard_handle_keymap(void* data, struct wl_keyboard* wl_keyboard,
+                                   uint32_t format, int fd, uint32_t size) {
+  if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
+    close(fd);
+    return;
+  }
+
+  char* mapString = (char*)mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
+  if (mapString == MAP_FAILED) {
+    close(fd);
+    return;
+  }
+
+  static auto sXkbContextNew =
+      (struct xkb_context * (*)(enum xkb_context_flags))
+          dlsym(RTLD_DEFAULT, "xkb_context_new");
+  static auto sXkbKeymapNewFromString =
+      (struct xkb_keymap * (*)(struct xkb_context*, const char*,
+                               enum xkb_keymap_format,
+                               enum xkb_keymap_compile_flags))
+          dlsym(RTLD_DEFAULT, "xkb_keymap_new_from_string");
+
+  struct xkb_context* xkb_context = sXkbContextNew(XKB_CONTEXT_NO_FLAGS);
+  struct xkb_keymap* keymap =
+      sXkbKeymapNewFromString(xkb_context, mapString, XKB_KEYMAP_FORMAT_TEXT_V1,
+                              XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+  munmap(mapString, size);
+  close(fd);
+
+  if (!keymap) {
+    NS_WARNING("keyboard_handle_keymap(): Failed to compile keymap!\n");
+    return;
+  }
+
+  KeymapWrapper::SetModifierMasks(keymap);
+
+  static auto sXkbKeymapUnRef =
+      (void (*)(struct xkb_keymap*))dlsym(RTLD_DEFAULT, "xkb_keymap_unref");
+  sXkbKeymapUnRef(keymap);
+
+  static auto sXkbContextUnref =
+      (void (*)(struct xkb_context*))dlsym(RTLD_DEFAULT, "xkb_context_unref");
+  sXkbContextUnref(xkb_context);
+}
+
+static void keyboard_handle_enter(void* data, struct wl_keyboard* keyboard,
+                                  uint32_t serial, struct wl_surface* surface,
+                                  struct wl_array* keys) {}
+static void keyboard_handle_leave(void* data, struct wl_keyboard* keyboard,
+                                  uint32_t serial, struct wl_surface* surface) {
+}
+static void keyboard_handle_key(void* data, struct wl_keyboard* keyboard,
+                                uint32_t serial, uint32_t time, uint32_t key,
+                                uint32_t state) {}
+static void keyboard_handle_modifiers(void* data, struct wl_keyboard* keyboard,
+                                      uint32_t serial, uint32_t mods_depressed,
+                                      uint32_t mods_latched,
+                                      uint32_t mods_locked, uint32_t group) {}
+
+static const struct wl_keyboard_listener keyboard_listener = {
+    keyboard_handle_keymap, keyboard_handle_enter,     keyboard_handle_leave,
+    keyboard_handle_key,    keyboard_handle_modifiers,
+};
+
+static void seat_handle_capabilities(void* data, struct wl_seat* seat,
+                                     unsigned int caps) {
+  static wl_keyboard* keyboard = nullptr;
+
+  if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !keyboard) {
+    keyboard = wl_seat_get_keyboard(seat);
+    wl_keyboard_add_listener(keyboard, &keyboard_listener, nullptr);
+  } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && keyboard) {
+    wl_keyboard_destroy(keyboard);
+    keyboard = nullptr;
+  }
+}
+
+static const struct wl_seat_listener seat_listener = {
+    seat_handle_capabilities,
+};
+
+static void gdk_registry_handle_global(void* data, struct wl_registry* registry,
+                                       uint32_t id, const char* interface,
+                                       uint32_t version) {
+  if (strcmp(interface, "wl_seat") == 0) {
+    wl_seat* seat =
+        (wl_seat*)wl_registry_bind(registry, id, &wl_seat_interface, 1);
+    wl_seat_add_listener(seat, &seat_listener, data);
+  }
+}
+
+static void gdk_registry_handle_global_remove(void* data,
+                                              struct wl_registry* registry,
+                                              uint32_t id) {}
+
+static const struct wl_registry_listener keyboard_registry_listener = {
+    gdk_registry_handle_global, gdk_registry_handle_global_remove};
+
+void KeymapWrapper::InitBySystemSettingsWayland() {
+  // Available as of GTK 3.8+
+  static auto sGdkWaylandDisplayGetWlDisplay = (wl_display * (*)(GdkDisplay*))
+      dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_display");
+  wl_display* display =
+      sGdkWaylandDisplayGetWlDisplay(gdk_display_get_default());
+  wl_registry_add_listener(wl_display_get_registry(display),
+                           &keyboard_registry_listener, this);
+}
+#endif
+
 KeymapWrapper::~KeymapWrapper() {
   gdk_window_remove_filter(nullptr, FilterEvents, this);
   g_signal_handlers_disconnect_by_func(mGdkKeymap,
@@ -1473,6 +1638,14 @@ void KeymapWrapper::WillDispatchKeyboard
 
 void KeymapWrapper::WillDispatchKeyboardEventInternal(
     WidgetKeyboardEvent& aKeyEvent, GdkEventKey* aGdkKeyEvent) {
+  if (!aGdkKeyEvent) {
+    // If aGdkKeyEvent is nullptr, we're trying to dispatch a fake keyboard
+    // event in such case, we don't need to set alternative char codes.
+    // So, we don't need to do nothing here.  This case is typically we're
+    // dispatching eKeyDown or eKeyUp event during composition.
+    return;
+  }
+
   uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
   if (!charCode) {
     MOZ_LOG(gKeymapWrapperLog, LogLevel::Info,
diff -up thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.h.wayland thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.h
--- thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.h.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsGtkKeyUtils.h	2019-02-05 14:26:16.976316645 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -13,6 +13,10 @@
 
 #include <gdk/gdk.h>
 #include <X11/XKBlib.h>
+#ifdef MOZ_WAYLAND
+#include <gdk/gdkwayland.h>
+#include <xkbcommon/xkbcommon.h>
+#endif
 
 namespace mozilla {
 namespace widget {
@@ -145,6 +149,14 @@ class KeymapWrapper {
   static void WillDispatchKeyboardEvent(WidgetKeyboardEvent& aKeyEvent,
                                         GdkEventKey* aGdkKeyEvent);
 
+#ifdef MOZ_WAYLAND
+  /**
+   * Utility function to set all supported modifier masks
+   * from xkb_keymap. We call that from Wayland backend routines.
+   */
+  static void SetModifierMasks(xkb_keymap* aKeymap);
+#endif
+
   /**
    * Destroys the singleton KeymapWrapper instance, if it exists.
    */
@@ -168,7 +180,10 @@ class KeymapWrapper {
    */
   void Init();
   void InitXKBExtension();
-  void InitBySystemSettings();
+  void InitBySystemSettingsX11();
+#ifdef MOZ_WAYLAND
+  void InitBySystemSettingsWayland();
+#endif
 
   /**
    * mModifierKeys stores each hardware key information.
@@ -360,6 +375,14 @@ class KeymapWrapper {
    */
   void WillDispatchKeyboardEventInternal(WidgetKeyboardEvent& aKeyEvent,
                                          GdkEventKey* aGdkKeyEvent);
+
+#ifdef MOZ_WAYLAND
+  /**
+   * Utility function to set Xkb modifier key mask.
+   */
+  void SetModifierMask(xkb_keymap* aKeymap, ModifierIndex aModifierIndex,
+                       const char* aModifierName);
+#endif
 };
 
 }  // namespace widget
diff -up thunderbird-60.5.0/widget/gtk/nsLookAndFeel.cpp.wayland thunderbird-60.5.0/widget/gtk/nsLookAndFeel.cpp
--- thunderbird-60.5.0/widget/gtk/nsLookAndFeel.cpp.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsLookAndFeel.cpp	2019-02-05 14:26:16.977316642 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -18,6 +18,7 @@
 
 #include <fontconfig/fontconfig.h>
 #include "gfxPlatformGtk.h"
+//#include "mozilla/FontPropertyTypes.h"
 #include "ScreenHelperGTK.h"
 
 #include "gtkdrawing.h"
@@ -31,7 +32,9 @@
 #include <cairo-gobject.h>
 #include "WidgetStyleCache.h"
 #include "prenv.h"
+#include "nsCSSColorUtils.h"
 
+using namespace mozilla;
 using mozilla::LookAndFeel;
 
 #define GDK_COLOR_TO_NS_RGB(c) \
@@ -170,7 +173,7 @@ static bool GetBorderColors(GtkStyleCont
     // GTK has an initial value of zero for border-widths, and so themes
     // need to explicitly set border-widths to make borders visible.
     GtkBorder border;
-    gtk_style_context_get_border(aContext, GTK_STATE_FLAG_NORMAL, &border);
+    gtk_style_context_get_border(aContext, state, &border);
     visible = border.top != 0 || border.right != 0 || border.bottom != 0 ||
               border.left != 0;
   }
@@ -199,6 +202,57 @@ static bool GetBorderColors(GtkStyleCont
   return ret;
 }
 
+// Finds ideal cell highlight colors used for unfocused+selected cells distinct
+// from both Highlight, used as focused+selected background, and the listbox
+// background which is assumed to be similar to -moz-field
+nsresult nsLookAndFeel::InitCellHighlightColors() {
+  // NS_SUFFICIENT_LUMINOSITY_DIFFERENCE is the a11y standard for text
+  // on a background. Use 20% of that standard since we have a background
+  // on top of another background
+  int32_t minLuminosityDifference = NS_SUFFICIENT_LUMINOSITY_DIFFERENCE / 5;
+  int32_t backLuminosityDifference =
+      NS_LUMINOSITY_DIFFERENCE(mMozWindowBackground, mMozFieldBackground);
+  if (backLuminosityDifference >= minLuminosityDifference) {
+    mMozCellHighlightBackground = mMozWindowBackground;
+    mMozCellHighlightText = mMozWindowText;
+    return NS_OK;
+  }
+
+  uint16_t hue, sat, luminance;
+  uint8_t alpha;
+  mMozCellHighlightBackground = mMozFieldBackground;
+  mMozCellHighlightText = mMozFieldText;
+
+  NS_RGB2HSV(mMozCellHighlightBackground, hue, sat, luminance, alpha);
+
+  uint16_t step = 30;
+  // Lighten the color if the color is very dark
+  if (luminance <= step) {
+    luminance += step;
+  }
+  // Darken it if it is very light
+  else if (luminance >= 255 - step) {
+    luminance -= step;
+  }
+  // Otherwise, compute what works best depending on the text luminance.
+  else {
+    uint16_t textHue, textSat, textLuminance;
+    uint8_t textAlpha;
+    NS_RGB2HSV(mMozCellHighlightText, textHue, textSat, textLuminance,
+               textAlpha);
+    // Text is darker than background, use a lighter shade
+    if (textLuminance < luminance) {
+      luminance += step;
+    }
+    // Otherwise, use a darker shade
+    else {
+      luminance -= step;
+    }
+  }
+  NS_HSV2RGB(mMozCellHighlightBackground, hue, sat, luminance, alpha);
+  return NS_OK;
+}
+
 void nsLookAndFeel::NativeInit() { EnsureInit(); }
 
 void nsLookAndFeel::RefreshImpl() {
@@ -248,7 +302,6 @@ nsresult nsLookAndFeel::NativeGetColor(C
     case eColorID_IMESelectedRawTextBackground:
     case eColorID_IMESelectedConvertedTextBackground:
     case eColorID__moz_dragtargetzone:
-    case eColorID__moz_cellhighlight:
     case eColorID__moz_html_cellhighlight:
     case eColorID_highlight:  // preference selected item,
       aColor = mTextSelectedBackground;
@@ -258,10 +311,15 @@ nsresult nsLookAndFeel::NativeGetColor(C
     case eColorID_IMESelectedRawTextForeground:
     case eColorID_IMESelectedConvertedTextForeground:
     case eColorID_highlighttext:
-    case eColorID__moz_cellhighlighttext:
     case eColorID__moz_html_cellhighlighttext:
       aColor = mTextSelectedText;
       break;
+    case eColorID__moz_cellhighlight:
+      aColor = mMozCellHighlightBackground;
+      break;
+    case eColorID__moz_cellhighlighttext:
+      aColor = mMozCellHighlightText;
+      break;
     case eColorID_Widget3DHighlight:
       aColor = NS_RGB(0xa0, 0xa0, 0xa0);
       break;
@@ -961,6 +1019,9 @@ void nsLookAndFeel::EnsureInit() {
   mOddCellBackground = GDK_RGBA_TO_NS_RGBA(color);
   gtk_style_context_restore(style);
 
+  // Compute cell highlight colors
+  InitCellHighlightColors();
+
   // GtkFrame has a "border" subnode on which Adwaita draws the border.
   // Some themes do not draw on this node but draw a border on the widget
   // root node, so check the root node if no border is found on the border
diff -up thunderbird-60.5.0/widget/gtk/nsLookAndFeel.h.wayland thunderbird-60.5.0/widget/gtk/nsLookAndFeel.h
--- thunderbird-60.5.0/widget/gtk/nsLookAndFeel.h.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsLookAndFeel.h	2019-02-05 14:26:16.977316642 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -8,6 +8,7 @@
 #ifndef __nsLookAndFeel
 #define __nsLookAndFeel
 
+#include "X11UndefineNone.h"
 #include "nsXPLookAndFeel.h"
 #include "nsCOMPtr.h"
 #include "gfxFont.h"
@@ -75,6 +76,8 @@ class nsLookAndFeel final : public nsXPL
   nscolor mMozWindowActiveBorder;
   nscolor mMozWindowInactiveBorder;
   nscolor mMozWindowInactiveCaption;
+  nscolor mMozCellHighlightBackground;
+  nscolor mMozCellHighlightText;
   nscolor mTextSelectedText;
   nscolor mTextSelectedBackground;
   nscolor mMozScrollbar;
@@ -89,6 +92,9 @@ class nsLookAndFeel final : public nsXPL
   bool mInitialized;
 
   void EnsureInit();
+
+ private:
+  nsresult InitCellHighlightColors();
 };
 
 #endif
diff -up thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.cpp.wayland thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.cpp
--- thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.cpp.wayland	2019-02-05 14:26:16.977316642 +0100
+++ thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.cpp	2019-02-05 14:26:16.977316642 +0100
@@ -0,0 +1,222 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsWaylandDisplay.h"
+
+#include "base/message_loop.h"  // for MessageLoop
+#include "base/task.h"          // for NewRunnableMethod, etc
+#include "mozilla/StaticMutex.h"
+
+namespace mozilla {
+namespace widget {
+
+#define MAX_DISPLAY_CONNECTIONS 2
+
+static nsWaylandDisplay *gWaylandDisplays[MAX_DISPLAY_CONNECTIONS];
+static StaticMutex gWaylandDisplaysMutex;
+
+// Each thread which is using wayland connection (wl_display) has to operate
+// its own wl_event_queue. Main Firefox thread wl_event_queue is handled
+// by Gtk main loop, other threads/wl_event_queue has to be handled by us.
+//
+// nsWaylandDisplay is our interface to wayland compositor. It provides wayland
+// global objects as we need (wl_display, wl_shm) and operates wl_event_queue on
+// compositor (not the main) thread.
+static void WaylandDisplayLoop(wl_display *aDisplay);
+
+// Get WaylandDisplay for given wl_display and actual calling thread.
+static nsWaylandDisplay *WaylandDisplayGetLocked(wl_display *aDisplay,
+                                                 const StaticMutexAutoLock &) {
+  for (auto &display : gWaylandDisplays) {
+    if (display && display->Matches(aDisplay)) {
+      NS_ADDREF(display);
+      return display;
+    }
+  }
+
+  for (auto &display : gWaylandDisplays) {
+    if (display == nullptr) {
+      display = new nsWaylandDisplay(aDisplay);
+      NS_ADDREF(display);
+      return display;
+    }
+  }
+
+  MOZ_CRASH("There's too many wayland display conections!");
+  return nullptr;
+}
+
+nsWaylandDisplay *WaylandDisplayGet(GdkDisplay *aGdkDisplay) {
+  if (!aGdkDisplay) {
+    aGdkDisplay = gdk_display_get_default();
+  }
+
+  // Available as of GTK 3.8+
+  static auto sGdkWaylandDisplayGetWlDisplay = (wl_display * (*)(GdkDisplay *))
+      dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_display");
+
+  wl_display *display = sGdkWaylandDisplayGetWlDisplay(aGdkDisplay);
+
+  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
+  return WaylandDisplayGetLocked(display, lock);
+}
+
+static bool WaylandDisplayReleaseLocked(nsWaylandDisplay *aDisplay,
+                                        const StaticMutexAutoLock &) {
+  for (auto &display : gWaylandDisplays) {
+    if (display == aDisplay) {
+      int rc = display->Release();
+      if (rc == 0) {
+        display = nullptr;
+      }
+      return true;
+    }
+  }
+  MOZ_ASSERT(false, "Missing nsWaylandDisplay for this thread!");
+  return false;
+}
+
+void WaylandDisplayRelease(nsWaylandDisplay *aDisplay) {
+  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
+  WaylandDisplayReleaseLocked(aDisplay, lock);
+}
+
+static void WaylandDisplayLoopLocked(wl_display *aDisplay,
+                                     const StaticMutexAutoLock &) {
+  for (auto &display : gWaylandDisplays) {
+    if (display && display->Matches(aDisplay)) {
+      if (display->DisplayLoop()) {
+        MessageLoop::current()->PostDelayedTask(
+            NewRunnableFunction("WaylandDisplayLoop", &WaylandDisplayLoop,
+                                aDisplay),
+            EVENT_LOOP_DELAY);
+      }
+      break;
+    }
+  }
+}
+
+static void WaylandDisplayLoop(wl_display *aDisplay) {
+  MOZ_ASSERT(!NS_IsMainThread());
+  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
+  WaylandDisplayLoopLocked(aDisplay, lock);
+}
+
+void nsWaylandDisplay::SetShm(wl_shm *aShm) { mShm = aShm; }
+
+void nsWaylandDisplay::SetSubcompositor(wl_subcompositor *aSubcompositor) {
+  mSubcompositor = aSubcompositor;
+}
+
+void nsWaylandDisplay::SetDataDeviceManager(
+    wl_data_device_manager *aDataDeviceManager) {
+  mDataDeviceManager = aDataDeviceManager;
+}
+
+void nsWaylandDisplay::SetSeat(wl_seat *aSeat) { mSeat = aSeat; }
+
+void nsWaylandDisplay::SetPrimarySelectionDeviceManager(
+    gtk_primary_selection_device_manager *aPrimarySelectionDeviceManager) {
+  mPrimarySelectionDeviceManager = aPrimarySelectionDeviceManager;
+}
+
+static void global_registry_handler(void *data, wl_registry *registry,
+                                    uint32_t id, const char *interface,
+                                    uint32_t version) {
+  auto display = reinterpret_cast<nsWaylandDisplay *>(data);
+
+  if (strcmp(interface, "wl_shm") == 0) {
+    auto shm = static_cast<wl_shm *>(
+        wl_registry_bind(registry, id, &wl_shm_interface, 1));
+    wl_proxy_set_queue((struct wl_proxy *)shm, display->GetEventQueue());
+    display->SetShm(shm);
+  } else if (strcmp(interface, "wl_data_device_manager") == 0) {
+    int data_device_manager_version = MIN(version, 3);
+    auto data_device_manager = static_cast<wl_data_device_manager *>(
+        wl_registry_bind(registry, id, &wl_data_device_manager_interface,
+                         data_device_manager_version));
+    wl_proxy_set_queue((struct wl_proxy *)data_device_manager,
+                       display->GetEventQueue());
+    display->SetDataDeviceManager(data_device_manager);
+  } else if (strcmp(interface, "wl_seat") == 0) {
+    auto seat = static_cast<wl_seat *>(
+        wl_registry_bind(registry, id, &wl_seat_interface, 1));
+    wl_proxy_set_queue((struct wl_proxy *)seat, display->GetEventQueue());
+    display->SetSeat(seat);
+  } else if (strcmp(interface, "gtk_primary_selection_device_manager") == 0) {
+    auto primary_selection_device_manager =
+        static_cast<gtk_primary_selection_device_manager *>(wl_registry_bind(
+            registry, id, &gtk_primary_selection_device_manager_interface, 1));
+    wl_proxy_set_queue((struct wl_proxy *)primary_selection_device_manager,
+                       display->GetEventQueue());
+    display->SetPrimarySelectionDeviceManager(primary_selection_device_manager);
+  } else if (strcmp(interface, "wl_subcompositor") == 0) {
+    auto subcompositor = static_cast<wl_subcompositor *>(
+        wl_registry_bind(registry, id, &wl_subcompositor_interface, 1));
+    wl_proxy_set_queue((struct wl_proxy *)subcompositor,
+                       display->GetEventQueue());
+    display->SetSubcompositor(subcompositor);
+  }
+}
+
+static void global_registry_remover(void *data, wl_registry *registry,
+                                    uint32_t id) {}
+
+static const struct wl_registry_listener registry_listener = {
+    global_registry_handler, global_registry_remover};
+
+bool nsWaylandDisplay::DisplayLoop() {
+  wl_display_dispatch_queue_pending(mDisplay, mEventQueue);
+  return true;
+}
+
+bool nsWaylandDisplay::Matches(wl_display *aDisplay) {
+  return mThreadId == PR_GetCurrentThread() && aDisplay == mDisplay;
+}
+
+NS_IMPL_ISUPPORTS(nsWaylandDisplay, nsISupports);
+
+nsWaylandDisplay::nsWaylandDisplay(wl_display *aDisplay)
+    : mThreadId(PR_GetCurrentThread()),
+      mDisplay(aDisplay),
+      mEventQueue(nullptr),
+      mDataDeviceManager(nullptr),
+      mSubcompositor(nullptr),
+      mSeat(nullptr),
+      mShm(nullptr),
+      mPrimarySelectionDeviceManager(nullptr) {
+  wl_registry *registry = wl_display_get_registry(mDisplay);
+  wl_registry_add_listener(registry, &registry_listener, this);
+
+  if (NS_IsMainThread()) {
+    // Use default event queue in main thread operated by Gtk+.
+    mEventQueue = nullptr;
+    wl_display_roundtrip(mDisplay);
+    wl_display_roundtrip(mDisplay);
+  } else {
+    mEventQueue = wl_display_create_queue(mDisplay);
+    MessageLoop::current()->PostTask(NewRunnableFunction(
+        "WaylandDisplayLoop", &WaylandDisplayLoop, mDisplay));
+    wl_proxy_set_queue((struct wl_proxy *)registry, mEventQueue);
+    wl_display_roundtrip_queue(mDisplay, mEventQueue);
+    wl_display_roundtrip_queue(mDisplay, mEventQueue);
+  }
+}
+
+nsWaylandDisplay::~nsWaylandDisplay() {
+  MOZ_ASSERT(mThreadId == PR_GetCurrentThread());
+  // Owned by Gtk+, we don't need to release
+  mDisplay = nullptr;
+
+  if (mEventQueue) {
+    wl_event_queue_destroy(mEventQueue);
+    mEventQueue = nullptr;
+  }
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff -up thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.h.wayland thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.h
--- thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.h.wayland	2019-02-05 14:26:16.977316642 +0100
+++ thunderbird-60.5.0/widget/gtk/nsWaylandDisplay.h	2019-02-05 14:26:16.977316642 +0100
@@ -0,0 +1,72 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __MOZ_WAYLAND_REGISTRY_H__
+#define __MOZ_WAYLAND_REGISTRY_H__
+
+#include "nsISupports.h"
+#include "mozwayland/mozwayland.h"
+#include "wayland/gtk-primary-selection-client-protocol.h"
+
+namespace mozilla {
+namespace widget {
+
+// TODO: Bug 1467125 - We need to integrate wl_display_dispatch_queue_pending()
+// with compositor event loop.
+#define EVENT_LOOP_DELAY (1000 / 240)
+
+// Our general connection to Wayland display server,
+// holds our display connection and runs event loop.
+class nsWaylandDisplay : public nsISupports {
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+ public:
+  explicit nsWaylandDisplay(wl_display* aDisplay);
+
+  bool DisplayLoop();
+  bool Matches(wl_display* aDisplay);
+
+  wl_display* GetDisplay() { return mDisplay; };
+  wl_event_queue* GetEventQueue() { return mEventQueue; };
+  wl_subcompositor* GetSubcompositor(void) { return mSubcompositor; };
+  wl_data_device_manager* GetDataDeviceManager(void) {
+    return mDataDeviceManager;
+  };
+  wl_seat* GetSeat(void) { return mSeat; };
+  wl_shm* GetShm(void) { return mShm; };
+  gtk_primary_selection_device_manager* GetPrimarySelectionDeviceManager(void) {
+    return mPrimarySelectionDeviceManager;
+  };
+
+ public:
+  void SetShm(wl_shm* aShm);
+  void SetSubcompositor(wl_subcompositor* aSubcompositor);
+  void SetDataDeviceManager(wl_data_device_manager* aDataDeviceManager);
+  void SetSeat(wl_seat* aSeat);
+  void SetPrimarySelectionDeviceManager(
+      gtk_primary_selection_device_manager* aPrimarySelectionDeviceManager);
+
+ private:
+  virtual ~nsWaylandDisplay();
+
+  PRThread* mThreadId;
+  wl_display* mDisplay;
+  wl_event_queue* mEventQueue;
+  wl_data_device_manager* mDataDeviceManager;
+  wl_subcompositor* mSubcompositor;
+  wl_seat* mSeat;
+  wl_shm* mShm;
+  gtk_primary_selection_device_manager* mPrimarySelectionDeviceManager;
+};
+
+nsWaylandDisplay* WaylandDisplayGet(GdkDisplay* aGdkDisplay = nullptr);
+void WaylandDisplayRelease(nsWaylandDisplay* aDisplay);
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // __MOZ_WAYLAND_REGISTRY_H__
diff -up thunderbird-60.5.0/widget/gtk/nsWindow.cpp.wayland thunderbird-60.5.0/widget/gtk/nsWindow.cpp
--- thunderbird-60.5.0/widget/gtk/nsWindow.cpp.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsWindow.cpp	2019-02-05 14:26:16.978316639 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -18,6 +18,7 @@
 #include "mozilla/TouchEvents.h"
 #include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/WidgetUtils.h"
+#include "mozilla/dom/WheelEventBinding.h"
 #include <algorithm>
 
 #include "GeckoProfiler.h"
@@ -25,13 +26,15 @@
 #include "prlink.h"
 #include "nsGTKToolkit.h"
 #include "nsIRollupListener.h"
-#include "nsIDOMNode.h"
+#include "nsINode.h"
 
 #include "nsWidgetsCID.h"
 #include "nsDragService.h"
 #include "nsIWidgetListener.h"
 #include "nsIScreenManager.h"
 #include "SystemTimeConverter.h"
+#include "nsIPresShell.h"
+#include "nsViewManager.h"
 
 #include "nsGtkKeyUtils.h"
 #include "nsGtkCursors.h"
@@ -56,6 +59,7 @@
 
 #if defined(MOZ_WAYLAND)
 #include <gdk/gdkwayland.h>
+#include "nsView.h"
 #endif
 
 #include "nsGkAtoms.h"
@@ -116,6 +120,7 @@ using namespace mozilla::widget;
 #include "mozilla/layers/CompositorThread.h"
 
 #ifdef MOZ_X11
+#include "GLContextGLX.h"  // for GLContextGLX::FindVisual()
 #include "GtkCompositorWidget.h"
 #include "gfxXlibSurface.h"
 #include "WindowSurfaceX11Image.h"
@@ -129,8 +134,6 @@ using namespace mozilla::widget;
 #include "nsShmImage.h"
 #include "gtkdrawing.h"
 
-#include "nsIDOMWheelEvent.h"
-
 #include "NativeKeyBindings.h"
 
 #include <dlfcn.h>
@@ -140,6 +143,7 @@ using namespace mozilla::gfx;
 using namespace mozilla::widget;
 using namespace mozilla::layers;
 using mozilla::gl::GLContext;
+using mozilla::gl::GLContextGLX;
 
 // Don't put more than this many rects in the dirty region, just fluff
 // out to the bounding-box if there are more
@@ -152,9 +156,12 @@ const gint kEvents =
 #if GTK_CHECK_VERSION(3, 4, 0)
     GDK_SMOOTH_SCROLL_MASK | GDK_TOUCH_MASK |
 #endif
-    GDK_SCROLL_MASK | GDK_POINTER_MOTION_MASK | GDK_PROPERTY_CHANGE_MASK;
+    GDK_SCROLL_MASK | GDK_POINTER_MOTION_MASK | GDK_PROPERTY_CHANGE_MASK |
+    GDK_FOCUS_CHANGE_MASK;
 
 /* utility functions */
+static void theme_changed_cb(GtkSettings *settings, GParamSpec *pspec,
+                             nsWindow *data);
 static bool is_mouse_in_window(GdkWindow *aWindow, gdouble aMouseX,
                                gdouble aMouseY);
 static nsWindow *get_window_for_gtk_widget(GtkWidget *widget);
@@ -196,8 +203,6 @@ static void hierarchy_changed_cb(GtkWidg
                                  GtkWidget *previous_toplevel);
 static gboolean window_state_event_cb(GtkWidget *widget,
                                       GdkEventWindowState *event);
-static void theme_changed_cb(GtkSettings *settings, GParamSpec *pspec,
-                             nsWindow *data);
 static void check_resize_cb(GtkContainer *container, gpointer user_data);
 static void screen_composited_changed_cb(GdkScreen *screen, gpointer user_data);
 static void widget_composited_changed_cb(GtkWidget *widget, gpointer user_data);
@@ -550,7 +555,7 @@ static GtkWidget *EnsureInvisibleContain
 }
 
 static void CheckDestroyInvisibleContainer() {
-  NS_PRECONDITION(gInvisibleContainer, "oh, no");
+  MOZ_ASSERT(gInvisibleContainer, "oh, no");
 
   if (!gdk_window_peek_children(gtk_widget_get_window(gInvisibleContainer))) {
     // No children, so not in use.
@@ -639,9 +644,6 @@ void nsWindow::Destroy() {
 
   ClearCachedResources();
 
-  g_signal_handlers_disconnect_by_func(gtk_settings_get_default(),
-                                       FuncToGpointer(theme_changed_cb), this);
-
   nsIRollupListener *rollupListener = nsBaseWidget::GetActiveRollupListener();
   if (rollupListener) {
     nsCOMPtr<nsIWidget> rollupWidget = rollupListener->GetRollupWidget();
@@ -725,7 +727,7 @@ double nsWindow::GetDefaultScaleInternal
 DesktopToLayoutDeviceScale nsWindow::GetDesktopToDeviceScale() {
 #ifdef MOZ_WAYLAND
   GdkDisplay *gdkDisplay = gdk_display_get_default();
-  if (GDK_IS_WAYLAND_DISPLAY(gdkDisplay)) {
+  if (!GDK_IS_X11_DISPLAY(gdkDisplay)) {
     return DesktopToLayoutDeviceScale(GdkScaleFactor());
   }
 #endif
@@ -735,8 +737,14 @@ DesktopToLayoutDeviceScale nsWindow::Get
 }
 
 void nsWindow::SetParent(nsIWidget *aNewParent) {
-  if (mContainer || !mGdkWindow) {
-    NS_NOTREACHED("nsWindow::SetParent called illegally");
+  if (!mGdkWindow) {
+    MOZ_ASSERT_UNREACHABLE("The native window has already been destroyed");
+    return;
+  }
+
+  if (mContainer) {
+    // FIXME bug 1469183
+    NS_ERROR("nsWindow should not have a container here");
     return;
   }
 
@@ -774,7 +782,7 @@ void nsWindow::SetParent(nsIWidget *aNew
 bool nsWindow::WidgetTypeSupportsAcceleration() { return !IsSmallPopup(); }
 
 void nsWindow::ReparentNativeWidget(nsIWidget *aNewParent) {
-  NS_PRECONDITION(aNewParent, "");
+  MOZ_ASSERT(aNewParent, "null widget");
   NS_ASSERTION(!mIsDestroyed, "");
   NS_ASSERTION(!static_cast<nsWindow *>(aNewParent)->mIsDestroyed, "");
 
@@ -1331,7 +1339,7 @@ LayoutDeviceIntRect nsWindow::GetClientB
 }
 
 void nsWindow::UpdateClientOffset() {
-  AUTO_PROFILER_LABEL("nsWindow::UpdateClientOffset", GRAPHICS);
+  AUTO_PROFILER_LABEL("nsWindow::UpdateClientOffset", OTHER);
 
   if (!mIsTopLevel || !mShell || !mIsX11Display ||
       gtk_window_get_window_type(GTK_WINDOW(mShell)) == GTK_WINDOW_POPUP) {
@@ -1373,9 +1381,7 @@ LayoutDeviceIntPoint nsWindow::GetClient
 }
 
 gboolean nsWindow::OnPropertyNotifyEvent(GtkWidget *aWidget,
-                                         GdkEventProperty *aEvent)
-
-{
+                                         GdkEventProperty *aEvent) {
   if (aEvent->atom == gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE)) {
     UpdateClientOffset();
 
@@ -1820,6 +1826,9 @@ gboolean nsWindow::OnExposeEvent(cairo_t
 
   // Windows that are not visible will be painted after they become visible.
   if (!mGdkWindow || mIsFullyObscured || !mHasMappedToplevel) return FALSE;
+#ifdef MOZ_WAYLAND
+  if (mContainer && !mContainer->ready_to_draw) return FALSE;
+#endif
 
   nsIWidgetListener *listener = GetListener();
   if (!listener) return FALSE;
@@ -3000,6 +3009,33 @@ void nsWindow::OnWindowStateEvent(GtkWid
   }
   // else the widget is a shell widget.
 
+  // The block below is a bit evil.
+  //
+  // When a window is resized before it is shown, gtk_window_resize() delays
+  // resizes until the window is shown.  If gtk_window_state_event() sees a
+  // GDK_WINDOW_STATE_MAXIMIZED change [1] before the window is shown, then
+  // gtk_window_compute_configure_request_size() ignores the values from the
+  // resize [2].  See bug 1449166 for an example of how this could happen.
+  //
+  // [1] https://gitlab.gnome.org/GNOME/gtk/blob/3.22.30/gtk/gtkwindow.c#L7967
+  // [2] https://gitlab.gnome.org/GNOME/gtk/blob/3.22.30/gtk/gtkwindow.c#L9377
+  //
+  // In order to provide a sensible size for the window when the user exits
+  // maximized state, we hide the GDK_WINDOW_STATE_MAXIMIZED change from
+  // gtk_window_state_event() so as to trick GTK into using the values from
+  // gtk_window_resize() in its configure request.
+  //
+  // We instead notify gtk_window_state_event() of the maximized state change
+  // once the window is shown.
+  if (!mIsShown) {
+    aEvent->changed_mask = static_cast<GdkWindowState>(
+        aEvent->changed_mask & ~GDK_WINDOW_STATE_MAXIMIZED);
+  } else if (aEvent->changed_mask & GDK_WINDOW_STATE_WITHDRAWN &&
+             aEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) {
+    aEvent->changed_mask = static_cast<GdkWindowState>(
+        aEvent->changed_mask | GDK_WINDOW_STATE_MAXIMIZED);
+  }
+
   // We don't care about anything but changes in the maximized/icon/fullscreen
   // states
   if ((aEvent->changed_mask &
@@ -3075,6 +3111,7 @@ void nsWindow::OnDPIChanged() {
       // Update menu's font size etc
       presShell->ThemeChanged();
     }
+    mWidgetListener->UIResolutionChanged();
   }
 }
 
@@ -3443,13 +3480,15 @@ nsresult nsWindow::Create(nsIWidget *aPa
                         gtk_style_context_has_class(style, "csd");
       eventWidget = (drawToContainer) ? container : mShell;
 
-      gtk_widget_add_events(eventWidget, kEvents);
-      if (drawToContainer)
-        gtk_widget_add_events(mShell, GDK_PROPERTY_CHANGE_MASK);
-
       // Prevent GtkWindow from painting a background to avoid flickering.
       gtk_widget_set_app_paintable(eventWidget, TRUE);
 
+      gtk_widget_add_events(eventWidget, kEvents);
+      if (drawToContainer) {
+        gtk_widget_add_events(mShell, GDK_PROPERTY_CHANGE_MASK);
+        gtk_widget_set_app_paintable(mShell, TRUE);
+      }
+
       // If we draw to mContainer window then configure it now because
       // gtk_container_add() realizes the child widget.
       gtk_widget_set_has_window(container, drawToContainer);
@@ -3698,6 +3737,15 @@ nsresult nsWindow::Create(nsIWidget *aPa
     mXDepth = gdk_visual_get_depth(gdkVisual);
 
     mSurfaceProvider.Initialize(mXDisplay, mXWindow, mXVisual, mXDepth);
+
+    if (mIsTopLevel) {
+      // Set window manager hint to keep fullscreen windows composited.
+      //
+      // If the window were to get unredirected, there could be visible
+      // tearing because Gecko does not align its framebuffer updates with
+      // vblank.
+      // SetCompositorHint(GTK_WIDGET_COMPOSIDED_ENABLED);
+    }
   }
 #ifdef MOZ_WAYLAND
   else if (!mIsX11Display) {
@@ -3708,12 +3756,37 @@ nsresult nsWindow::Create(nsIWidget *aPa
   return NS_OK;
 }
 
+void nsWindow::RefreshWindowClass(void) {
+  if (mGtkWindowTypeName.IsEmpty() || mGtkWindowRoleName.IsEmpty()) return;
+
+  GdkWindow *gdkWindow = gtk_widget_get_window(mShell);
+  gdk_window_set_role(gdkWindow, mGtkWindowRoleName.get());
+
+#ifdef MOZ_X11
+  if (mIsX11Display) {
+    XClassHint *class_hint = XAllocClassHint();
+    if (!class_hint) {
+      return;
+    }
+    const char *res_class = gdk_get_program_class();
+    if (!res_class) return;
+
+    class_hint->res_name = const_cast<char *>(mGtkWindowTypeName.get());
+    class_hint->res_class = const_cast<char *>(res_class);
+
+    // Can't use gtk_window_set_wmclass() for this; it prints
+    // a warning & refuses to make the change.
+    GdkDisplay *display = gdk_display_get_default();
+    XSetClassHint(GDK_DISPLAY_XDISPLAY(display),
+                  gdk_x11_window_get_xid(gdkWindow), class_hint);
+    XFree(class_hint);
+  }
+#endif /* MOZ_X11 */
+}
+
 void nsWindow::SetWindowClass(const nsAString &xulWinType) {
   if (!mShell) return;
 
-  const char *res_class = gdk_get_program_class();
-  if (!res_class) return;
-
   char *res_name = ToNewCString(xulWinType);
   if (!res_name) return;
 
@@ -3733,29 +3806,11 @@ void nsWindow::SetWindowClass(const nsAS
   res_name[0] = toupper(res_name[0]);
   if (!role) role = res_name;
 
-  GdkWindow *gdkWindow = gtk_widget_get_window(mShell);
-  gdk_window_set_role(gdkWindow, role);
-
-#ifdef MOZ_X11
-  if (mIsX11Display) {
-    XClassHint *class_hint = XAllocClassHint();
-    if (!class_hint) {
-      free(res_name);
-      return;
-    }
-    class_hint->res_name = res_name;
-    class_hint->res_class = const_cast<char *>(res_class);
-
-    // Can't use gtk_window_set_wmclass() for this; it prints
-    // a warning & refuses to make the change.
-    GdkDisplay *display = gdk_display_get_default();
-    XSetClassHint(GDK_DISPLAY_XDISPLAY(display),
-                  gdk_x11_window_get_xid(gdkWindow), class_hint);
-    XFree(class_hint);
-  }
-#endif /* MOZ_X11 */
-
+  mGtkWindowTypeName = res_name;
+  mGtkWindowRoleName = role;
   free(res_name);
+
+  RefreshWindowClass();
 }
 
 void nsWindow::NativeResize() {
@@ -3820,6 +3875,8 @@ void nsWindow::NativeMoveResize() {
       NativeShow(false);
     }
     NativeMove();
+
+    return;
   }
 
   GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mBounds.Size());
@@ -3832,6 +3889,8 @@ void nsWindow::NativeMoveResize() {
     // x and y give the position of the window manager frame top-left.
     gtk_window_move(GTK_WINDOW(mShell), topLeft.x, topLeft.y);
     // This sets the client window size.
+    MOZ_ASSERT(size.width > 0 && size.height > 0,
+               "Can't resize window smaller than 1x1.");
     gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
   } else if (mContainer) {
     GtkAllocation allocation;
@@ -3877,6 +3936,16 @@ void nsWindow::NativeShow(bool aAction)
       gdk_window_show_unraised(mGdkWindow);
     }
   } else {
+#ifdef MOZ_WAYLAND
+    if (mContainer && moz_container_has_wl_egl_window(mContainer)) {
+      // Because wl_egl_window is destroyed on moz_container_unmap(),
+      // the current compositor cannot use it anymore. To avoid crash,
+      // destroy the compositor & recreate a new compositor on next
+      // expose event.
+      DestroyLayerManager();
+    }
+#endif
+
     if (mIsTopLevel) {
       // Workaround window freezes on GTK versions before 3.21.2 by
       // ensuring that configure events get dispatched to windows before
@@ -5436,9 +5505,10 @@ void nsWindow::InitDragEvent(WidgetDragE
   KeymapWrapper::InitInputEvent(aEvent, modifierState);
 }
 
-static gboolean drag_motion_event_cb(GtkWidget *aWidget,
-                                     GdkDragContext *aDragContext, gint aX,
-                                     gint aY, guint aTime, gpointer aData) {
+gboolean WindowDragMotionHandler(GtkWidget *aWidget,
+                                 GdkDragContext *aDragContext,
+                                 nsWaylandDragContext *aWaylandDragContext,
+                                 gint aX, gint aY, guint aTime) {
   RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
   if (!window) return FALSE;
 
@@ -5459,13 +5529,17 @@ static gboolean drag_motion_event_cb(Gtk
   LayoutDeviceIntPoint point = window->GdkPointToDevicePixels({retx, rety});
 
   RefPtr<nsDragService> dragService = nsDragService::GetInstance();
-  return dragService->ScheduleMotionEvent(innerMostWindow, aDragContext, point,
-                                          aTime);
+  return dragService->ScheduleMotionEvent(innerMostWindow, aDragContext,
+                                          aWaylandDragContext, point, aTime);
 }
 
-static void drag_leave_event_cb(GtkWidget *aWidget,
-                                GdkDragContext *aDragContext, guint aTime,
-                                gpointer aData) {
+static gboolean drag_motion_event_cb(GtkWidget *aWidget,
+                                     GdkDragContext *aDragContext, gint aX,
+                                     gint aY, guint aTime, gpointer aData) {
+  return WindowDragMotionHandler(aWidget, aDragContext, nullptr, aX, aY, aTime);
+}
+
+void WindowDragLeaveHandler(GtkWidget *aWidget) {
   RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
   if (!window) return;
 
@@ -5495,9 +5569,15 @@ static void drag_leave_event_cb(GtkWidge
   dragService->ScheduleLeaveEvent();
 }
 
-static gboolean drag_drop_event_cb(GtkWidget *aWidget,
-                                   GdkDragContext *aDragContext, gint aX,
-                                   gint aY, guint aTime, gpointer aData) {
+static void drag_leave_event_cb(GtkWidget *aWidget,
+                                GdkDragContext *aDragContext, guint aTime,
+                                gpointer aData) {
+  WindowDragLeaveHandler(aWidget);
+}
+
+gboolean WindowDragDropHandler(GtkWidget *aWidget, GdkDragContext *aDragContext,
+                               nsWaylandDragContext *aWaylandDragContext,
+                               gint aX, gint aY, guint aTime) {
   RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
   if (!window) return FALSE;
 
@@ -5518,8 +5598,14 @@ static gboolean drag_drop_event_cb(GtkWi
   LayoutDeviceIntPoint point = window->GdkPointToDevicePixels({retx, rety});
 
   RefPtr<nsDragService> dragService = nsDragService::GetInstance();
-  return dragService->ScheduleDropEvent(innerMostWindow, aDragContext, point,
-                                        aTime);
+  return dragService->ScheduleDropEvent(innerMostWindow, aDragContext,
+                                        aWaylandDragContext, point, aTime);
+}
+
+static gboolean drag_drop_event_cb(GtkWidget *aWidget,
+                                   GdkDragContext *aDragContext, gint aX,
+                                   gint aY, guint aTime, gpointer aData) {
+  return WindowDragDropHandler(aWidget, aDragContext, nullptr, aX, aY, aTime);
 }
 
 static void drag_data_received_event_cb(GtkWidget *aWidget,
@@ -5877,11 +5963,6 @@ nsIWidget::LayerManager *nsWindow::GetLa
     return mLayerManager;
   }
 
-  if (!mLayerManager && !IsComposited() &&
-      eTransparencyTransparent == GetTransparencyMode()) {
-    mLayerManager = CreateBasicLayerManager();
-  }
-
   return nsBaseWidget::GetLayerManager(aShadowManager, aBackendHint,
                                        aPersistence);
 }
@@ -5919,6 +6000,13 @@ void nsWindow::ClearCachedResources() {
  * It works only for CSD decorated GtkWindow.
  */
 void nsWindow::UpdateClientOffsetForCSDWindow() {
+  // We update window offset on X11 as the window position is calculated
+  // relatively to mShell. We don't do that on Wayland as our wl_subsurface
+  // is attached to mContainer and mShell is ignored.
+  if (!mIsX11Display) {
+    return;
+  }
+
   // _NET_FRAME_EXTENTS is not set on client decorated windows,
   // so we need to read offset between mContainer and toplevel mShell
   // window.
@@ -6005,6 +6093,15 @@ void nsWindow::SetDrawsInTitlebar(bool a
     mNeedsShow = true;
     NativeResize();
 
+    // Label mShell toplevel window so property_notify_event_cb callback
+    // can find its way home.
+    g_object_set_data(G_OBJECT(gtk_widget_get_window(mShell)), "nsWindow",
+                      this);
+#ifdef MOZ_X11
+    // SetCompositorHint(GTK_WIDGET_COMPOSIDED_ENABLED);
+#endif
+    RefreshWindowClass();
+
     // When we use system titlebar setup managed by Gtk+ we also get
     // _NET_FRAME_EXTENTS property for our toplevel window so we can't
     // update the client offset it here.
@@ -6019,13 +6116,11 @@ void nsWindow::SetDrawsInTitlebar(bool a
 }
 
 gint nsWindow::GdkScaleFactor() {
-#if (MOZ_WIDGET_GTK >= 3)
   // Available as of GTK 3.10+
   static auto sGdkWindowGetScaleFactorPtr =
       (gint(*)(GdkWindow *))dlsym(RTLD_DEFAULT, "gdk_window_get_scale_factor");
   if (sGdkWindowGetScaleFactorPtr && mGdkWindow)
     return (*sGdkWindowGetScaleFactorPtr)(mGdkWindow);
-#endif
   return ScreenHelperGTK::GetGTKMonitorScaleFactor();
 }
 
@@ -6287,6 +6382,8 @@ nsWindow::CSDSupportLevel nsWindow::GetS
       // KDE Plasma
     } else if (strstr(currentDesktop, "KDE") != nullptr) {
       sCSDSupportLevel = CSD_SUPPORT_CLIENT;
+    } else if (strstr(currentDesktop, "Enlightenment") != nullptr) {
+      sCSDSupportLevel = CSD_SUPPORT_CLIENT;
     } else if (strstr(currentDesktop, "LXDE") != nullptr) {
       sCSDSupportLevel = CSD_SUPPORT_CLIENT;
     } else if (strstr(currentDesktop, "openbox") != nullptr) {
@@ -6303,6 +6400,8 @@ nsWindow::CSDSupportLevel nsWindow::GetS
       sCSDSupportLevel = CSD_SUPPORT_SYSTEM;
     } else if (strstr(currentDesktop, "LXQt") != nullptr) {
       sCSDSupportLevel = CSD_SUPPORT_SYSTEM;
+    } else if (strstr(currentDesktop, "Deepin") != nullptr) {
+      sCSDSupportLevel = CSD_SUPPORT_SYSTEM;
     } else {
 // Release or beta builds are not supposed to be broken
 // so disable titlebar rendering on untested/unknown systems.
@@ -6351,34 +6450,19 @@ int32_t nsWindow::RoundsWidgetCoordinate
 
 void nsWindow::GetCompositorWidgetInitData(
     mozilla::widget::CompositorWidgetInitData *aInitData) {
+  // Make sure the window XID is propagated to X server, we can fail otherwise
+  // in GPU process (Bug 1401634).
+  if (mXDisplay && mXWindow != X11None) {
+    XFlush(mXDisplay);
+  }
+
   *aInitData = mozilla::widget::GtkCompositorWidgetInitData(
       (mXWindow != X11None) ? mXWindow : (uintptr_t) nullptr,
       mXDisplay ? nsCString(XDisplayString(mXDisplay)) : nsCString(),
       GetClientSize());
 }
 
-bool nsWindow::IsComposited() const {
-  if (!mGdkWindow) {
-    NS_WARNING("nsWindow::HasARGBVisual called before realization!");
-    return false;
-  }
-
-  GdkScreen *gdkScreen = gdk_screen_get_default();
-  return gdk_screen_is_composited(gdkScreen) &&
-         (gdk_window_get_visual(mGdkWindow) ==
-          gdk_screen_get_rgba_visual(gdkScreen));
-}
-
 #ifdef MOZ_WAYLAND
-wl_display *nsWindow::GetWaylandDisplay() {
-  // Available as of GTK 3.8+
-  static auto sGdkWaylandDisplayGetWlDisplay = (wl_display * (*)(GdkDisplay *))
-      dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_wl_display");
-
-  GdkDisplay *gdkDisplay = gdk_display_get_default();
-  return mIsX11Display ? nullptr : sGdkWaylandDisplayGetWlDisplay(gdkDisplay);
-}
-
 wl_surface *nsWindow::GetWaylandSurface() {
   if (mContainer)
     return moz_container_get_wl_surface(MOZ_CONTAINER(mContainer));
@@ -6388,4 +6472,80 @@ wl_surface *nsWindow::GetWaylandSurface(
       "drawing!");
   return nullptr;
 }
+
+bool nsWindow::WaylandSurfaceNeedsClear() {
+  if (mContainer) {
+    return moz_container_surface_needs_clear(MOZ_CONTAINER(mContainer));
+  }
+
+  NS_WARNING(
+      "nsWindow::WaylandSurfaceNeedsClear(): We don't have any mContainer!");
+  return false;
+}
 #endif
+
+#ifdef MOZ_X11
+/* XApp progress support currently works by setting a property
+ * on a window with this Atom name.  A supporting window manager
+ * will notice this and pass it along to whatever handling has
+ * been implemented on that end (e.g. passing it on to a taskbar
+ * widget.)  There is no issue if WM support is lacking, this is
+ * simply ignored in that case.
+ *
+ * See https://github.com/linuxmint/xapps/blob/master/libxapp/xapp-gtk-window.c
+ * for further details.
+ */
+
+#define PROGRESS_HINT "_NET_WM_XAPP_PROGRESS"
+
+static void set_window_hint_cardinal(Window xid, const gchar *atom_name,
+                                     gulong cardinal) {
+  GdkDisplay *display;
+
+  display = gdk_display_get_default();
+
+  if (cardinal > 0) {
+    XChangeProperty(GDK_DISPLAY_XDISPLAY(display), xid,
+                    gdk_x11_get_xatom_by_name_for_display(display, atom_name),
+                    XA_CARDINAL, 32, PropModeReplace, (guchar *)&cardinal, 1);
+  } else {
+    XDeleteProperty(GDK_DISPLAY_XDISPLAY(display), xid,
+                    gdk_x11_get_xatom_by_name_for_display(display, atom_name));
+  }
+}
+#endif  // MOZ_X11
+
+void nsWindow::SetProgress(unsigned long progressPercent) {
+#ifdef MOZ_X11
+
+  if (!mIsX11Display) {
+    return;
+  }
+
+  if (!mShell) {
+    return;
+  }
+
+  progressPercent = MIN(progressPercent, 100);
+
+  set_window_hint_cardinal(GDK_WINDOW_XID(gtk_widget_get_window(mShell)),
+                           PROGRESS_HINT, progressPercent);
+#endif  // MOZ_X11
+}
+
+#ifdef MOZ_X11
+void nsWindow::SetCompositorHint(WindowComposeRequest aState) {
+  if (mIsX11Display &&
+      (!GetLayerManager() ||
+       GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_BASIC)) {
+    gulong value = aState;
+    GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
+    gdk_property_change(gtk_widget_get_window(mShell),
+                        gdk_atom_intern("_NET_WM_BYPASS_COMPOSITOR", FALSE),
+                        cardinal_atom,
+                        32,  // format
+                        GDK_PROP_MODE_REPLACE, (guchar *)&value, 1);
+  }
+}
+#endif
+
diff -up thunderbird-60.5.0/widget/gtk/nsWindow.h.wayland thunderbird-60.5.0/widget/gtk/nsWindow.h
--- thunderbird-60.5.0/widget/gtk/nsWindow.h.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/nsWindow.h	2019-02-05 14:26:16.978316639 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* This Source Code Form is subject to the terms of the Mozilla Public
@@ -8,19 +8,8 @@
 #ifndef __nsWindow_h__
 #define __nsWindow_h__
 
-#include "mozcontainer.h"
-#include "mozilla/RefPtr.h"
-#include "mozilla/UniquePtr.h"
-#include "nsIDragService.h"
-#include "nsITimer.h"
-#include "nsGkAtoms.h"
-#include "nsRefPtrHashtable.h"
-
-#include "nsBaseWidget.h"
-#include "CompositorWidget.h"
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
-
 #ifdef MOZ_X11
 #include <gdk/gdkx.h>
 #include "X11UndefineNone.h"
@@ -28,7 +17,16 @@
 #ifdef MOZ_WAYLAND
 #include <gdk/gdkwayland.h>
 #endif
-
+#include "mozcontainer.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsIDragService.h"
+#include "nsITimer.h"
+#include "nsGkAtoms.h"
+#include "nsRefPtrHashtable.h"
+#include "nsIFrame.h"
+#include "nsBaseWidget.h"
+#include "CompositorWidget.h"
 #include "mozilla/widget/WindowSurface.h"
 #include "mozilla/widget/WindowSurfaceProvider.h"
 
@@ -66,6 +64,19 @@ extern mozilla::LazyLogModule gWidgetDra
 
 #endif /* MOZ_LOGGING */
 
+#ifdef MOZ_WAYLAND
+class nsWaylandDragContext;
+
+gboolean WindowDragMotionHandler(GtkWidget* aWidget,
+                                 GdkDragContext* aDragContext,
+                                 nsWaylandDragContext* aWaylandDragContext,
+                                 gint aX, gint aY, guint aTime);
+gboolean WindowDragDropHandler(GtkWidget* aWidget, GdkDragContext* aDragContext,
+                               nsWaylandDragContext* aWaylandDragContext,
+                               gint aX, gint aY, guint aTime);
+void WindowDragLeaveHandler(GtkWidget* aWidget);
+#endif
+
 class gfxPattern;
 
 namespace mozilla {
@@ -77,6 +88,7 @@ class nsWindow final : public nsBaseWidg
  public:
   typedef mozilla::gfx::DrawTarget DrawTarget;
   typedef mozilla::WidgetEventTime WidgetEventTime;
+  typedef mozilla::WidgetKeyboardEvent WidgetKeyboardEvent;
   typedef mozilla::widget::PlatformCompositorWidgetDelegate
       PlatformCompositorWidgetDelegate;
 
@@ -216,6 +228,8 @@ class nsWindow final : public nsBaseWidg
       mozilla::gfx::DrawTarget* aDrawTarget,
       LayoutDeviceIntRegion& aInvalidRegion) override;
 
+  void SetProgress(unsigned long progressPercent);
+
  private:
   void UpdateAlpha(mozilla::gfx::SourceSurface* aSourceSurface,
                    nsIntRect aBoundsRect);
@@ -335,6 +349,7 @@ class nsWindow final : public nsBaseWidg
 #ifdef MOZ_WAYLAND
   wl_display* GetWaylandDisplay();
   wl_surface* GetWaylandSurface();
+  bool WaylandSurfaceNeedsClear();
 #endif
   virtual void GetCompositorWidgetInitData(
       mozilla::widget::CompositorWidgetInitData* aInitData) override;
@@ -436,13 +451,23 @@ class nsWindow final : public nsBaseWidg
                    gint* aButton, gint* aRootX, gint* aRootY);
   void ClearCachedResources();
   nsIWidgetListener* GetListener();
-  bool IsComposited() const;
 
   void UpdateClientOffsetForCSDWindow();
 
   nsWindow* GetTransientForWindowIfPopup();
   bool IsHandlingTouchSequence(GdkEventSequence* aSequence);
 
+#ifdef MOZ_X11
+  typedef enum {GTK_WIDGET_COMPOSIDED_DEFAULT = 0,
+                GTK_WIDGET_COMPOSIDED_DISABLED = 1,
+                GTK_WIDGET_COMPOSIDED_ENABLED = 2} WindowComposeRequest;
+
+  void SetCompositorHint(WindowComposeRequest aState);
+#endif
+  nsCString mGtkWindowTypeName;
+  nsCString mGtkWindowRoleName;
+  void RefreshWindowClass();
+
   GtkWidget* mShell;
   MozContainer* mContainer;
   GdkWindow* mGdkWindow;
diff -up thunderbird-60.5.0/widget/gtk/WindowSurfaceProvider.h.wayland thunderbird-60.5.0/widget/gtk/WindowSurfaceProvider.h
--- thunderbird-60.5.0/widget/gtk/WindowSurfaceProvider.h.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/WindowSurfaceProvider.h	2019-02-05 14:26:16.978316639 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -17,6 +17,7 @@
 #include <gdk/gdkwayland.h>
 #endif
 #include <X11/Xlib.h>  // for Window, Display, Visual, etc.
+#include "X11UndefineNone.h"
 
 class nsWindow;
 
@@ -70,6 +71,7 @@ class WindowSurfaceProvider final {
 #ifdef MOZ_WAYLAND
   nsWindow* mWidget;
 #endif
+  bool mIsShaped;
 };
 
 }  // namespace widget
diff -up thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.cpp.wayland thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.cpp
--- thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.cpp.wayland	2019-01-22 20:44:04.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.cpp	2019-02-05 14:26:16.979316635 +0100
@@ -1,27 +1,28 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "nsWaylandDisplay.h"
 #include "WindowSurfaceWayland.h"
 
-#include "base/message_loop.h"  // for MessageLoop
-#include "base/task.h"          // for NewRunnableMethod, etc
 #include "nsPrintfCString.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/gfx/Tools.h"
 #include "gfxPlatform.h"
 #include "mozcontainer.h"
-#include "nsCOMArray.h"
-#include "mozilla/StaticMutex.h"
+#include "nsTArray.h"
+#include "base/message_loop.h"  // for MessageLoop
+#include "base/task.h"          // for NewRunnableMethod, etc
 
-#include <gdk/gdkwayland.h>
 #include <sys/mman.h>
-#include <assert.h>
 #include <fcntl.h>
 #include <errno.h>
 
+namespace mozilla {
+namespace widget {
+
 /*
   Wayland multi-thread rendering scheme
 
@@ -131,188 +132,16 @@ handle to wayland compositor by WindowBa
 (wl_buffer/wl_surface).
 */
 
-namespace mozilla {
-namespace widget {
-
 #define BUFFER_BPP 4
-
-// TODO: How many rendering threads do we actualy handle?
-static nsCOMArray<nsWaylandDisplay> gWaylandDisplays;
-static StaticMutex gWaylandDisplaysMutex;
-
-// Each thread which is using wayland connection (wl_display) has to operate
-// its own wl_event_queue. Main Firefox thread wl_event_queue is handled
-// by Gtk main loop, other threads/wl_event_queue has to be handled by us.
-//
-// nsWaylandDisplay is our interface to wayland compositor. It provides wayland
-// global objects as we need (wl_display, wl_shm) and operates wl_event_queue on
-// compositor (not the main) thread.
-static nsWaylandDisplay *WaylandDisplayGet(wl_display *aDisplay);
-static void WaylandDisplayRelease(wl_display *aDisplay);
-static void WaylandDisplayLoop(wl_display *aDisplay);
-
-// TODO: is the 60pfs loop correct?
-#define EVENT_LOOP_DELAY (1000 / 60)
-
-// Get WaylandDisplay for given wl_display and actual calling thread.
-static nsWaylandDisplay *WaylandDisplayGetLocked(wl_display *aDisplay,
-                                                 const StaticMutexAutoLock &) {
-  nsWaylandDisplay *waylandDisplay = nullptr;
-
-  int len = gWaylandDisplays.Count();
-  for (int i = 0; i < len; i++) {
-    if (gWaylandDisplays[i]->Matches(aDisplay)) {
-      waylandDisplay = gWaylandDisplays[i];
-      break;
-    }
-  }
-
-  if (!waylandDisplay) {
-    waylandDisplay = new nsWaylandDisplay(aDisplay);
-    gWaylandDisplays.AppendObject(waylandDisplay);
-  }
-
-  NS_ADDREF(waylandDisplay);
-  return waylandDisplay;
-}
-
-static nsWaylandDisplay *WaylandDisplayGet(wl_display *aDisplay) {
-  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
-  return WaylandDisplayGetLocked(aDisplay, lock);
-}
-
-static bool WaylandDisplayReleaseLocked(wl_display *aDisplay,
-                                        const StaticMutexAutoLock &) {
-  int len = gWaylandDisplays.Count();
-  for (int i = 0; i < len; i++) {
-    if (gWaylandDisplays[i]->Matches(aDisplay)) {
-      int rc = gWaylandDisplays[i]->Release();
-      // nsCOMArray::AppendObject()/RemoveObjectAt() also call
-      // AddRef()/Release() so remove WaylandDisplay when ref count is 1.
-      if (rc == 1) {
-        gWaylandDisplays.RemoveObjectAt(i);
-      }
-      return true;
-    }
-  }
-  MOZ_ASSERT(false, "Missing nsWaylandDisplay for this thread!");
-  return false;
-}
-
-static void WaylandDisplayRelease(wl_display *aDisplay) {
-  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
-  WaylandDisplayReleaseLocked(aDisplay, lock);
-}
-
-static void WaylandDisplayLoopLocked(wl_display *aDisplay,
-                                     const StaticMutexAutoLock &) {
-  int len = gWaylandDisplays.Count();
-  for (int i = 0; i < len; i++) {
-    if (gWaylandDisplays[i]->Matches(aDisplay)) {
-      if (gWaylandDisplays[i]->DisplayLoop()) {
-        MessageLoop::current()->PostDelayedTask(
-            NewRunnableFunction("WaylandDisplayLoop", &WaylandDisplayLoop,
-                                aDisplay),
-            EVENT_LOOP_DELAY);
-      }
-      break;
-    }
-  }
-}
-
-static void WaylandDisplayLoop(wl_display *aDisplay) {
-  MOZ_ASSERT(!NS_IsMainThread());
-  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
-  WaylandDisplayLoopLocked(aDisplay, lock);
-}
-
-static void global_registry_handler(void *data, wl_registry *registry,
-                                    uint32_t id, const char *interface,
-                                    uint32_t version) {
-  if (strcmp(interface, "wl_shm") == 0) {
-    auto interface = reinterpret_cast<nsWaylandDisplay *>(data);
-    auto shm = static_cast<wl_shm *>(
-        wl_registry_bind(registry, id, &wl_shm_interface, 1));
-    wl_proxy_set_queue((struct wl_proxy *)shm, interface->GetEventQueue());
-    interface->SetShm(shm);
-  }
-}
-
-static void global_registry_remover(void *data, wl_registry *registry,
-                                    uint32_t id) {}
-
-static const struct wl_registry_listener registry_listener = {
-    global_registry_handler, global_registry_remover};
-
-wl_shm *nsWaylandDisplay::GetShm() {
-  MOZ_ASSERT(mThreadId == PR_GetCurrentThread());
-
-  if (!mShm) {
-    // wl_shm is not provided by Gtk so we need to query wayland directly
-    // See weston/simple-shm.c and create_display() for reference.
-    wl_registry *registry = wl_display_get_registry(mDisplay);
-    wl_registry_add_listener(registry, &registry_listener, this);
-
-    wl_proxy_set_queue((struct wl_proxy *)registry, mEventQueue);
-    if (mEventQueue) {
-      wl_display_roundtrip_queue(mDisplay, mEventQueue);
-    } else {
-      wl_display_roundtrip(mDisplay);
-    }
-
-    MOZ_RELEASE_ASSERT(mShm, "Wayland registry query failed!");
-  }
-
-  return (mShm);
-}
-
-bool nsWaylandDisplay::DisplayLoop() {
-  wl_display_dispatch_queue_pending(mDisplay, mEventQueue);
-  return true;
-}
-
-bool nsWaylandDisplay::Matches(wl_display *aDisplay) {
-  return mThreadId == PR_GetCurrentThread() && aDisplay == mDisplay;
-}
-
-NS_IMPL_ISUPPORTS(nsWaylandDisplay, nsISupports);
-
-nsWaylandDisplay::nsWaylandDisplay(wl_display *aDisplay)
-    : mThreadId(PR_GetCurrentThread())
-      // gfx::SurfaceFormat::B8G8R8A8 is a basic Wayland format
-      // and is always present.
-      ,
-      mFormat(gfx::SurfaceFormat::B8G8R8A8),
-      mShm(nullptr),
-      mDisplay(aDisplay) {
-  if (NS_IsMainThread()) {
-    // Use default event queue in main thread operated by Gtk+.
-    mEventQueue = nullptr;
-  } else {
-    mEventQueue = wl_display_create_queue(mDisplay);
-    MessageLoop::current()->PostTask(NewRunnableFunction(
-        "WaylandDisplayLoop", &WaylandDisplayLoop, mDisplay));
-  }
-}
-
-nsWaylandDisplay::~nsWaylandDisplay() {
-  MOZ_ASSERT(mThreadId == PR_GetCurrentThread());
-  // Owned by Gtk+, we don't need to release
-  mDisplay = nullptr;
-
-  if (mEventQueue) {
-    wl_event_queue_destroy(mEventQueue);
-    mEventQueue = nullptr;
-  }
-}
+gfx::SurfaceFormat WindowBackBuffer::mFormat = gfx::SurfaceFormat::B8G8R8A8;
 
 int WaylandShmPool::CreateTemporaryFile(int aSize) {
-  const char *tmppath = getenv("XDG_RUNTIME_DIR");
+  const char* tmppath = getenv("XDG_RUNTIME_DIR");
   MOZ_RELEASE_ASSERT(tmppath, "Missing XDG_RUNTIME_DIR env variable.");
 
   nsPrintfCString tmpname("%s/mozilla-shared-XXXXXX", tmppath);
 
-  char *filename;
+  char* filename;
   int fd = -1;
   int ret = 0;
 
@@ -353,7 +182,7 @@ int WaylandShmPool::CreateTemporaryFile(
   return fd;
 }
 
-WaylandShmPool::WaylandShmPool(nsWaylandDisplay *aWaylandDisplay, int aSize)
+WaylandShmPool::WaylandShmPool(nsWaylandDisplay* aWaylandDisplay, int aSize)
     : mAllocatedSize(aSize) {
   mShmPoolFd = CreateTemporaryFile(mAllocatedSize);
   mImageData = mmap(nullptr, mAllocatedSize, PROT_READ | PROT_WRITE, MAP_SHARED,
@@ -365,7 +194,7 @@ WaylandShmPool::WaylandShmPool(nsWayland
       wl_shm_create_pool(aWaylandDisplay->GetShm(), mShmPoolFd, mAllocatedSize);
 
   // We set our queue to get mShmPool events at compositor thread.
-  wl_proxy_set_queue((struct wl_proxy *)mShmPool,
+  wl_proxy_set_queue((struct wl_proxy*)mShmPool,
                      aWaylandDisplay->GetEventQueue());
 }
 
@@ -394,7 +223,7 @@ bool WaylandShmPool::Resize(int aSize) {
   return true;
 }
 
-void WaylandShmPool::SetImageDataFromPool(class WaylandShmPool *aSourcePool,
+void WaylandShmPool::SetImageDataFromPool(class WaylandShmPool* aSourcePool,
                                           int aImageDataSize) {
   MOZ_ASSERT(mAllocatedSize >= aImageDataSize, "WaylandShmPool overflows!");
   memcpy(mImageData, aSourcePool->GetImageData(), aImageDataSize);
@@ -406,8 +235,8 @@ WaylandShmPool::~WaylandShmPool() {
   close(mShmPoolFd);
 }
 
-static void buffer_release(void *data, wl_buffer *buffer) {
-  auto surface = reinterpret_cast<WindowBackBuffer *>(data);
+static void buffer_release(void* data, wl_buffer* buffer) {
+  auto surface = reinterpret_cast<WindowBackBuffer*>(data);
   surface->Detach();
 }
 
@@ -422,7 +251,7 @@ void WindowBackBuffer::Create(int aWidth
   mWaylandBuffer =
       wl_shm_pool_create_buffer(mShmPool.GetShmPool(), 0, aWidth, aHeight,
                                 aWidth * BUFFER_BPP, WL_SHM_FORMAT_ARGB8888);
-  wl_proxy_set_queue((struct wl_proxy *)mWaylandBuffer,
+  wl_proxy_set_queue((struct wl_proxy*)mWaylandBuffer,
                      mWaylandDisplay->GetEventQueue());
   wl_buffer_add_listener(mWaylandBuffer, &buffer_listener, this);
 
@@ -435,7 +264,11 @@ void WindowBackBuffer::Release() {
   mWidth = mHeight = 0;
 }
 
-WindowBackBuffer::WindowBackBuffer(nsWaylandDisplay *aWaylandDisplay,
+void WindowBackBuffer::Clear() {
+  memset(mShmPool.GetImageData(), 0, mHeight * mWidth * BUFFER_BPP);
+}
+
+WindowBackBuffer::WindowBackBuffer(nsWaylandDisplay* aWaylandDisplay,
                                    int aWidth, int aHeight)
     : mShmPool(aWaylandDisplay, aWidth * aHeight * BUFFER_BPP),
       mWaylandBuffer(nullptr),
@@ -457,7 +290,7 @@ bool WindowBackBuffer::Resize(int aWidth
   return (mWaylandBuffer != nullptr);
 }
 
-void WindowBackBuffer::Attach(wl_surface *aSurface) {
+void WindowBackBuffer::Attach(wl_surface* aSurface) {
   wl_surface_attach(aSurface, mWaylandBuffer, 0, 0);
   wl_surface_commit(aSurface);
   wl_display_flush(mWaylandDisplay->GetDisplay());
@@ -466,8 +299,8 @@ void WindowBackBuffer::Attach(wl_surface
 
 void WindowBackBuffer::Detach() { mAttached = false; }
 
-bool WindowBackBuffer::SetImageDataFromBackBuffer(
-    class WindowBackBuffer *aSourceBuffer) {
+bool WindowBackBuffer::SetImageDataFromBuffer(
+    class WindowBackBuffer* aSourceBuffer) {
   if (!IsMatchingSize(aSourceBuffer)) {
     Resize(aSourceBuffer->mWidth, aSourceBuffer->mHeight);
   }
@@ -478,204 +311,381 @@ bool WindowBackBuffer::SetImageDataFromB
   return true;
 }
 
-already_AddRefed<gfx::DrawTarget> WindowBackBuffer::Lock(
-    const LayoutDeviceIntRegion &aRegion) {
-  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
-  gfx::IntSize lockSize(bounds.XMost(), bounds.YMost());
-
+already_AddRefed<gfx::DrawTarget> WindowBackBuffer::Lock() {
+  gfx::IntSize lockSize(mWidth, mHeight);
   return gfxPlatform::CreateDrawTargetForData(
-      static_cast<unsigned char *>(mShmPool.GetImageData()), lockSize,
-      BUFFER_BPP * mWidth, mWaylandDisplay->GetSurfaceFormat());
+      static_cast<unsigned char*>(mShmPool.GetImageData()), lockSize,
+      BUFFER_BPP * mWidth, mFormat);
 }
 
-static void frame_callback_handler(void *data, struct wl_callback *callback,
+static void frame_callback_handler(void* data, struct wl_callback* callback,
                                    uint32_t time) {
-  auto surface = reinterpret_cast<WindowSurfaceWayland *>(data);
+  auto surface = reinterpret_cast<WindowSurfaceWayland*>(data);
   surface->FrameCallbackHandler();
 }
 
 static const struct wl_callback_listener frame_listener = {
     frame_callback_handler};
 
-WindowSurfaceWayland::WindowSurfaceWayland(nsWindow *aWindow)
+WindowSurfaceWayland::WindowSurfaceWayland(nsWindow* aWindow)
     : mWindow(aWindow),
-      mWaylandDisplay(WaylandDisplayGet(aWindow->GetWaylandDisplay())),
-      mFrontBuffer(nullptr),
-      mBackBuffer(nullptr),
+      mWaylandDisplay(WaylandDisplayGet()),
+      mWaylandBuffer(nullptr),
       mFrameCallback(nullptr),
-      mFrameCallbackSurface(nullptr),
+      mLastCommittedSurface(nullptr),
       mDisplayThreadMessageLoop(MessageLoop::current()),
-      mDelayedCommit(false),
-      mFullScreenDamage(false),
-      mIsMainThread(NS_IsMainThread()) {}
+      mDelayedCommitHandle(nullptr),
+      mDrawToWaylandBufferDirectly(true),
+      mPendingCommit(false),
+      mWaylandBufferFullScreenDamage(false),
+      mIsMainThread(NS_IsMainThread()),
+      mNeedScaleFactorUpdate(true) {
+  for (int i = 0; i < BACK_BUFFER_NUM; i++) mBackupBuffer[i] = nullptr;
+}
 
 WindowSurfaceWayland::~WindowSurfaceWayland() {
-  delete mFrontBuffer;
-  delete mBackBuffer;
+  if (mPendingCommit) {
+    NS_WARNING("Deleted WindowSurfaceWayland with a pending commit!");
+  }
+
+  if (mDelayedCommitHandle) {
+    // Delete reference to this to prevent WaylandBufferDelayCommitHandler()
+    // operate on released this. mDelayedCommitHandle itself will
+    // be released at WaylandBufferDelayCommitHandler().
+    *mDelayedCommitHandle = nullptr;
+  }
 
   if (mFrameCallback) {
     wl_callback_destroy(mFrameCallback);
   }
 
+  delete mWaylandBuffer;
+
+  for (int i = 0; i < BACK_BUFFER_NUM; i++) {
+    if (mBackupBuffer[i]) {
+      delete mBackupBuffer[i];
+    }
+  }
+
   if (!mIsMainThread) {
     // We can be destroyed from main thread even though we was created/used
     // in compositor thread. We have to unref/delete WaylandDisplay in
     // compositor thread then and we can't use MessageLoop::current() here.
-    mDisplayThreadMessageLoop->PostTask(
-        NewRunnableFunction("WaylandDisplayRelease", &WaylandDisplayRelease,
-                            mWaylandDisplay->GetDisplay()));
+    mDisplayThreadMessageLoop->PostTask(NewRunnableFunction(
+        "WaylandDisplayRelease", &WaylandDisplayRelease, mWaylandDisplay));
   } else {
-    WaylandDisplayRelease(mWaylandDisplay->GetDisplay());
-  }
-}
-
-void WindowSurfaceWayland::UpdateScaleFactor() {
-  wl_surface *waylandSurface = mWindow->GetWaylandSurface();
-  if (waylandSurface) {
-    wl_surface_set_buffer_scale(waylandSurface, mWindow->GdkScaleFactor());
+    WaylandDisplayRelease(mWaylandDisplay);
   }
 }
 
-WindowBackBuffer *WindowSurfaceWayland::GetBufferToDraw(int aWidth,
-                                                        int aHeight) {
-  if (!mFrontBuffer) {
-    mFrontBuffer = new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
-    mBackBuffer = new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
-    return mFrontBuffer;
+WindowBackBuffer* WindowSurfaceWayland::GetWaylandBufferToDraw(int aWidth,
+                                                               int aHeight) {
+  if (!mWaylandBuffer) {
+    mWaylandBuffer = new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
+    return mWaylandBuffer;
   }
 
-  if (!mFrontBuffer->IsAttached()) {
-    if (!mFrontBuffer->IsMatchingSize(aWidth, aHeight)) {
-      mFrontBuffer->Resize(aWidth, aHeight);
+  if (!mWaylandBuffer->IsAttached()) {
+    if (!mWaylandBuffer->IsMatchingSize(aWidth, aHeight)) {
+      mWaylandBuffer->Resize(aWidth, aHeight);
       // There's a chance that scale factor has been changed
       // when buffer size changed
-      UpdateScaleFactor();
+      mNeedScaleFactorUpdate = true;
+    }
+    return mWaylandBuffer;
+  }
+
+  MOZ_ASSERT(!mPendingCommit,
+             "Uncommitted buffer switch, screen artifacts ahead.");
+
+  // Front buffer is used by compositor, select a back buffer
+  int availableBuffer;
+  for (availableBuffer = 0; availableBuffer < BACK_BUFFER_NUM;
+       availableBuffer++) {
+    if (!mBackupBuffer[availableBuffer]) {
+      mBackupBuffer[availableBuffer] =
+          new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
+      break;
+    }
+
+    if (!mBackupBuffer[availableBuffer]->IsAttached()) {
+      break;
     }
-    return mFrontBuffer;
   }
 
-  // Front buffer is used by compositor, draw to back buffer
-  if (mBackBuffer->IsAttached()) {
+  if (MOZ_UNLIKELY(availableBuffer == BACK_BUFFER_NUM)) {
     NS_WARNING("No drawing buffer available");
     return nullptr;
   }
 
-  MOZ_ASSERT(!mDelayedCommit,
-             "Uncommitted buffer switch, screen artifacts ahead.");
-
-  WindowBackBuffer *tmp = mFrontBuffer;
-  mFrontBuffer = mBackBuffer;
-  mBackBuffer = tmp;
+  WindowBackBuffer* lastWaylandBuffer = mWaylandBuffer;
+  mWaylandBuffer = mBackupBuffer[availableBuffer];
+  mBackupBuffer[availableBuffer] = lastWaylandBuffer;
 
-  if (mBackBuffer->IsMatchingSize(aWidth, aHeight)) {
+  if (lastWaylandBuffer->IsMatchingSize(aWidth, aHeight)) {
     // Former front buffer has the same size as a requested one.
     // Gecko may expect a content already drawn on screen so copy
     // existing data to the new buffer.
-    mFrontBuffer->SetImageDataFromBackBuffer(mBackBuffer);
+    mWaylandBuffer->SetImageDataFromBuffer(lastWaylandBuffer);
     // When buffer switches we need to damage whole screen
     // (https://bugzilla.redhat.com/show_bug.cgi?id=1418260)
-    mFullScreenDamage = true;
+    mWaylandBufferFullScreenDamage = true;
   } else {
     // Former buffer has different size from the new request. Only resize
     // the new buffer and leave gecko to render new whole content.
-    mFrontBuffer->Resize(aWidth, aHeight);
+    mWaylandBuffer->Resize(aWidth, aHeight);
   }
 
-  return mFrontBuffer;
+  return mWaylandBuffer;
 }
 
-already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::Lock(
-    const LayoutDeviceIntRegion &aRegion) {
-  MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
-
-  // We allocate back buffer to widget size but return only
-  // portion requested by aRegion.
-  LayoutDeviceIntRect rect = mWindow->GetBounds();
-  WindowBackBuffer *buffer = GetBufferToDraw(rect.width, rect.height);
+already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockWaylandBuffer(
+    int aWidth, int aHeight, bool aClearBuffer) {
+  WindowBackBuffer* buffer = GetWaylandBufferToDraw(aWidth, aHeight);
   if (!buffer) {
-    NS_WARNING("No drawing buffer available");
+    NS_WARNING(
+        "WindowSurfaceWayland::LockWaylandBuffer(): No buffer available");
     return nullptr;
   }
 
-  return buffer->Lock(aRegion);
+  if (aClearBuffer) {
+    buffer->Clear();
+  }
+
+  return buffer->Lock();
+}
+
+already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockImageSurface(
+    const gfx::IntSize& aLockSize) {
+  if (!mImageSurface || mImageSurface->CairoStatus() ||
+      !(aLockSize <= mImageSurface->GetSize())) {
+    mImageSurface = new gfxImageSurface(
+        aLockSize,
+        SurfaceFormatToImageFormat(WindowBackBuffer::GetSurfaceFormat()));
+    if (mImageSurface->CairoStatus()) {
+      return nullptr;
+    }
+  }
+
+  return gfxPlatform::CreateDrawTargetForData(
+      mImageSurface->Data(), mImageSurface->GetSize(), mImageSurface->Stride(),
+      WindowBackBuffer::GetSurfaceFormat());
 }
 
-void WindowSurfaceWayland::Commit(const LayoutDeviceIntRegion &aInvalidRegion) {
+/*
+  There are some situations which can happen here:
+
+  A) Lock() is called to whole surface. In that case we don't need
+     to clip/buffer the drawing and we can return wl_buffer directly
+     for drawing.
+       - mWaylandBuffer is available - that's an ideal situation.
+       - mWaylandBuffer is locked by compositor - flip buffers and draw.
+          - if we can't flip buffers - go B)
+
+  B) Lock() is requested for part(s) of screen. We need to provide temporary
+     surface to draw into and copy result (clipped) to target wl_surface.
+ */
+already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::Lock(
+    const LayoutDeviceIntRegion& aRegion) {
   MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
 
-  wl_surface *waylandSurface = mWindow->GetWaylandSurface();
+  LayoutDeviceIntRect screenRect = mWindow->GetBounds();
+  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
+  gfx::IntSize lockSize(bounds.XMost(), bounds.YMost());
+
+  // Are we asked for entire nsWindow to draw?
+  mDrawToWaylandBufferDirectly =
+      (aRegion.GetNumRects() == 1 && bounds.x == 0 && bounds.y == 0 &&
+       lockSize.width == screenRect.width &&
+       lockSize.height == screenRect.height);
+
+  if (mDrawToWaylandBufferDirectly) {
+    RefPtr<gfx::DrawTarget> dt =
+        LockWaylandBuffer(screenRect.width, screenRect.height,
+                          mWindow->WaylandSurfaceNeedsClear());
+    if (dt) {
+      return dt.forget();
+    }
+
+    // We don't have any front buffer available. Try indirect drawing
+    // to mImageSurface which is mirrored to front buffer at commit.
+    mDrawToWaylandBufferDirectly = false;
+  }
+
+  return LockImageSurface(lockSize);
+}
+
+bool WindowSurfaceWayland::CommitImageSurfaceToWaylandBuffer(
+    const LayoutDeviceIntRegion& aRegion) {
+  MOZ_ASSERT(!mDrawToWaylandBufferDirectly);
+
+  LayoutDeviceIntRect screenRect = mWindow->GetBounds();
+  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
+
+  gfx::Rect rect(bounds);
+  if (rect.IsEmpty()) {
+    return false;
+  }
+
+  RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(
+      screenRect.width, screenRect.height, mWindow->WaylandSurfaceNeedsClear());
+  RefPtr<gfx::SourceSurface> surf =
+      gfx::Factory::CreateSourceSurfaceForCairoSurface(
+          mImageSurface->CairoSurface(), mImageSurface->GetSize(),
+          mImageSurface->Format());
+  if (!dt || !surf) {
+    return false;
+  }
+
+  uint32_t numRects = aRegion.GetNumRects();
+  if (numRects != 1) {
+    AutoTArray<IntRect, 32> rects;
+    rects.SetCapacity(numRects);
+    for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
+      rects.AppendElement(iter.Get().ToUnknownRect());
+    }
+    dt->PushDeviceSpaceClipRects(rects.Elements(), rects.Length());
+  }
+
+  dt->DrawSurface(surf, rect, rect);
+
+  if (numRects != 1) {
+    dt->PopClip();
+  }
+
+  return true;
+}
+
+static void WaylandBufferDelayCommitHandler(WindowSurfaceWayland** aSurface) {
+  if (*aSurface) {
+    (*aSurface)->DelayedCommitHandler();
+  } else {
+    // Referenced WindowSurfaceWayland is already deleted.
+    // Do nothing but just release the mDelayedCommitHandle allocated at
+    // WindowSurfaceWayland::CommitWaylandBuffer().
+    free(aSurface);
+  }
+}
+
+void WindowSurfaceWayland::CommitWaylandBuffer() {
+  MOZ_ASSERT(mPendingCommit, "Committing empty surface!");
+
+  wl_surface* waylandSurface = mWindow->GetWaylandSurface();
   if (!waylandSurface) {
-    // Target window is already destroyed - don't bother to render there.
+    // Target window is not created yet - delay the commit. This can happen only
+    // when the window is newly created and there's no active
+    // frame callback pending.
+    MOZ_ASSERT(!mFrameCallback || waylandSurface != mLastCommittedSurface,
+               "Missing wayland surface at frame callback!");
+
+    // Do nothing if there's already mDelayedCommitHandle pending.
+    if (!mDelayedCommitHandle) {
+      mDelayedCommitHandle = static_cast<WindowSurfaceWayland**>(
+          moz_xmalloc(sizeof(*mDelayedCommitHandle)));
+      *mDelayedCommitHandle = this;
+
+      MessageLoop::current()->PostDelayedTask(
+          NewRunnableFunction("WaylandBackBufferCommit",
+                              &WaylandBufferDelayCommitHandler,
+                              mDelayedCommitHandle),
+          EVENT_LOOP_DELAY);
+    }
     return;
   }
-  wl_proxy_set_queue((struct wl_proxy *)waylandSurface,
+  wl_proxy_set_queue((struct wl_proxy*)waylandSurface,
                      mWaylandDisplay->GetEventQueue());
 
-  if (mFullScreenDamage) {
+  // We have an active frame callback request so handle it.
+  if (mFrameCallback) {
+    if (waylandSurface == mLastCommittedSurface) {
+      // We have an active frame callback pending from our recent surface.
+      // It means we should defer the commit to FrameCallbackHandler().
+      return;
+    }
+    // If our stored wl_surface does not match the actual one it means the frame
+    // callback is no longer active and we should release it.
+    wl_callback_destroy(mFrameCallback);
+    mFrameCallback = nullptr;
+    mLastCommittedSurface = nullptr;
+  }
+
+  if (mWaylandBufferFullScreenDamage) {
     LayoutDeviceIntRect rect = mWindow->GetBounds();
     wl_surface_damage(waylandSurface, 0, 0, rect.width, rect.height);
-    mFullScreenDamage = false;
+    mWaylandBufferFullScreenDamage = false;
   } else {
-    for (auto iter = aInvalidRegion.RectIter(); !iter.Done(); iter.Next()) {
-      const mozilla::LayoutDeviceIntRect &r = iter.Get();
-      wl_surface_damage(waylandSurface, r.x, r.y, r.width, r.height);
+    gint scaleFactor = mWindow->GdkScaleFactor();
+    for (auto iter = mWaylandBufferDamage.RectIter(); !iter.Done();
+         iter.Next()) {
+      const mozilla::LayoutDeviceIntRect& r = iter.Get();
+      // We need to remove the scale factor because the wl_surface_damage
+      // also multiplies by current  scale factor.
+      wl_surface_damage(waylandSurface, r.x / scaleFactor, r.y / scaleFactor,
+                        r.width / scaleFactor, r.height / scaleFactor);
     }
   }
 
-  // Frame callback is always connected to actual wl_surface. When the surface
-  // is unmapped/deleted the frame callback is never called. Unfortunatelly
-  // we don't know if the frame callback is not going to be called.
-  // But our mozcontainer code deletes wl_surface when the GdkWindow is hidden
-  // creates a new one when is visible.
-  if (mFrameCallback && mFrameCallbackSurface == waylandSurface) {
-    // Do nothing here - we have a valid wl_surface and the buffer will be
-    // commited to compositor in next frame callback event.
-    mDelayedCommit = true;
-    return;
-  } else {
-    if (mFrameCallback) {
-      // Delete frame callback connected to obsoleted wl_surface.
-      wl_callback_destroy(mFrameCallback);
-    }
+  // Clear all back buffer damage as we're committing
+  // all requested regions.
+  mWaylandBufferDamage.SetEmpty();
 
-    mFrameCallback = wl_surface_frame(waylandSurface);
-    wl_callback_add_listener(mFrameCallback, &frame_listener, this);
-    mFrameCallbackSurface = waylandSurface;
-
-    // There's no pending frame callback so we can draw immediately
-    // and create frame callback for possible subsequent drawing.
-    mFrontBuffer->Attach(waylandSurface);
-    mDelayedCommit = false;
+  mFrameCallback = wl_surface_frame(waylandSurface);
+  wl_callback_add_listener(mFrameCallback, &frame_listener, this);
+
+  if (mNeedScaleFactorUpdate || mLastCommittedSurface != waylandSurface) {
+    wl_surface_set_buffer_scale(waylandSurface, mWindow->GdkScaleFactor());
+    mNeedScaleFactorUpdate = false;
   }
+
+  mWaylandBuffer->Attach(waylandSurface);
+  mLastCommittedSurface = waylandSurface;
+
+  // There's no pending commit, all changes are sent to compositor.
+  mPendingCommit = false;
+}
+
+void WindowSurfaceWayland::Commit(const LayoutDeviceIntRegion& aInvalidRegion) {
+  MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
+
+  // We have new content at mImageSurface - copy data to mWaylandBuffer first.
+  if (!mDrawToWaylandBufferDirectly) {
+    CommitImageSurfaceToWaylandBuffer(aInvalidRegion);
+  }
+
+  // If we're not at fullscreen damage add drawing area from aInvalidRegion
+  if (!mWaylandBufferFullScreenDamage) {
+    mWaylandBufferDamage.OrWith(aInvalidRegion);
+  }
+
+  // We're ready to commit.
+  mPendingCommit = true;
+  CommitWaylandBuffer();
 }
 
 void WindowSurfaceWayland::FrameCallbackHandler() {
   MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
+  MOZ_ASSERT(mFrameCallback != nullptr,
+             "FrameCallbackHandler() called without valid frame callback!");
+  MOZ_ASSERT(mLastCommittedSurface != nullptr,
+             "FrameCallbackHandler() called without valid wl_surface!");
 
-  if (mFrameCallback) {
-    wl_callback_destroy(mFrameCallback);
-    mFrameCallback = nullptr;
-    mFrameCallbackSurface = nullptr;
+  wl_callback_destroy(mFrameCallback);
+  mFrameCallback = nullptr;
+
+  if (mPendingCommit) {
+    CommitWaylandBuffer();
   }
+}
 
-  if (mDelayedCommit) {
-    wl_surface *waylandSurface = mWindow->GetWaylandSurface();
-    if (!waylandSurface) {
-      // Target window is already destroyed - don't bother to render there.
-      NS_WARNING("No drawing buffer available");
-      return;
-    }
-    wl_proxy_set_queue((struct wl_proxy *)waylandSurface,
-                       mWaylandDisplay->GetEventQueue());
+void WindowSurfaceWayland::DelayedCommitHandler() {
+  MOZ_ASSERT(mDelayedCommitHandle != nullptr, "Missing mDelayedCommitHandle!");
 
-    // Send pending surface to compositor and register frame callback
-    // for possible subsequent drawing.
-    mFrameCallback = wl_surface_frame(waylandSurface);
-    wl_callback_add_listener(mFrameCallback, &frame_listener, this);
-    mFrameCallbackSurface = waylandSurface;
+  *mDelayedCommitHandle = nullptr;
+  free(mDelayedCommitHandle);
+  mDelayedCommitHandle = nullptr;
 
-    mFrontBuffer->Attach(waylandSurface);
-    mDelayedCommit = false;
+  if (mPendingCommit) {
+    CommitWaylandBuffer();
   }
 }
 
diff -up thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.h.wayland thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.h
--- thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.h.wayland	2019-01-22 20:44:03.000000000 +0100
+++ thunderbird-60.5.0/widget/gtk/WindowSurfaceWayland.h	2019-02-05 14:26:16.979316635 +0100
@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -8,37 +8,14 @@
 #define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_H
 
 #include <prthread.h>
+#include "mozilla/gfx/Types.h"
+#include "nsWaylandDisplay.h"
+
+#define BACK_BUFFER_NUM 2
 
 namespace mozilla {
 namespace widget {
 
-// Our general connection to Wayland display server,
-// holds our display connection and runs event loop.
-class nsWaylandDisplay : public nsISupports {
-  NS_DECL_THREADSAFE_ISUPPORTS
-
- public:
-  nsWaylandDisplay(wl_display* aDisplay);
-
-  wl_shm* GetShm();
-  void SetShm(wl_shm* aShm) { mShm = aShm; };
-
-  wl_display* GetDisplay() { return mDisplay; };
-  wl_event_queue* GetEventQueue() { return mEventQueue; };
-  gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; };
-  bool DisplayLoop();
-  bool Matches(wl_display* aDisplay);
-
- private:
-  virtual ~nsWaylandDisplay();
-
-  PRThread* mThreadId;
-  gfx::SurfaceFormat mFormat;
-  wl_shm* mShm;
-  wl_event_queue* mEventQueue;
-  wl_display* mDisplay;
-};
-
 // Allocates and owns shared memory for Wayland drawing surface
 class WaylandShmPool {
  public:
@@ -66,14 +43,15 @@ class WindowBackBuffer {
   WindowBackBuffer(nsWaylandDisplay* aDisplay, int aWidth, int aHeight);
   ~WindowBackBuffer();
 
-  already_AddRefed<gfx::DrawTarget> Lock(const LayoutDeviceIntRegion& aRegion);
+  already_AddRefed<gfx::DrawTarget> Lock();
 
   void Attach(wl_surface* aSurface);
   void Detach();
   bool IsAttached() { return mAttached; }
 
+  void Clear();
   bool Resize(int aWidth, int aHeight);
-  bool SetImageDataFromBackBuffer(class WindowBackBuffer* aSourceBuffer);
+  bool SetImageDataFromBuffer(class WindowBackBuffer* aSourceBuffer);
 
   bool IsMatchingSize(int aWidth, int aHeight) {
     return aWidth == mWidth && aHeight == mHeight;
@@ -82,6 +60,8 @@ class WindowBackBuffer {
     return aBuffer->mWidth == mWidth && aBuffer->mHeight == mHeight;
   }
 
+  static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
+
  private:
   void Create(int aWidth, int aHeight);
   void Release();
@@ -96,35 +76,48 @@ class WindowBackBuffer {
   int mHeight;
   bool mAttached;
   nsWaylandDisplay* mWaylandDisplay;
+  static gfx::SurfaceFormat mFormat;
 };
 
 // WindowSurfaceWayland is an abstraction for wl_surface
 // and related management
 class WindowSurfaceWayland : public WindowSurface {
  public:
-  WindowSurfaceWayland(nsWindow* aWindow);
+  explicit WindowSurfaceWayland(nsWindow* aWindow);
   ~WindowSurfaceWayland();
 
   already_AddRefed<gfx::DrawTarget> Lock(
       const LayoutDeviceIntRegion& aRegion) override;
   void Commit(const LayoutDeviceIntRegion& aInvalidRegion) final;
   void FrameCallbackHandler();
+  void DelayedCommitHandler();
 
  private:
-  WindowBackBuffer* GetBufferToDraw(int aWidth, int aHeight);
-  void UpdateScaleFactor();
+  WindowBackBuffer* GetWaylandBufferToDraw(int aWidth, int aHeight);
+
+  already_AddRefed<gfx::DrawTarget> LockWaylandBuffer(int aWidth, int aHeight,
+                                                      bool aClearBuffer);
+  already_AddRefed<gfx::DrawTarget> LockImageSurface(
+      const gfx::IntSize& aLockSize);
+  bool CommitImageSurfaceToWaylandBuffer(const LayoutDeviceIntRegion& aRegion);
+  void CommitWaylandBuffer();
 
   // TODO: Do we need to hold a reference to nsWindow object?
   nsWindow* mWindow;
   nsWaylandDisplay* mWaylandDisplay;
-  WindowBackBuffer* mFrontBuffer;
-  WindowBackBuffer* mBackBuffer;
+  WindowBackBuffer* mWaylandBuffer;
+  LayoutDeviceIntRegion mWaylandBufferDamage;
+  WindowBackBuffer* mBackupBuffer[BACK_BUFFER_NUM];
+  RefPtr<gfxImageSurface> mImageSurface;
   wl_callback* mFrameCallback;
-  wl_surface* mFrameCallbackSurface;
+  wl_surface* mLastCommittedSurface;
   MessageLoop* mDisplayThreadMessageLoop;
-  bool mDelayedCommit;
-  bool mFullScreenDamage;
+  WindowSurfaceWayland** mDelayedCommitHandle;
+  bool mDrawToWaylandBufferDirectly;
+  bool mPendingCommit;
+  bool mWaylandBufferFullScreenDamage;
   bool mIsMainThread;
+  bool mNeedScaleFactorUpdate;
 };
 
 }  // namespace widget
diff -up thunderbird-60.6.1/widget/gtk/WindowSurfaceProvider.cpp.old thunderbird-60.6.1/widget/gtk/WindowSurfaceProvider.cpp
--- thunderbird-60.6.1/widget/gtk/WindowSurfaceProvider.cpp.old	2019-05-14 21:11:50.219841534 +0200
+++ thunderbird-60.6.1/widget/gtk/WindowSurfaceProvider.cpp	2019-05-14 21:11:58.228755117 +0200
@@ -52,9 +52,6 @@ void WindowSurfaceProvider::Initialize(D
 
 #ifdef MOZ_WAYLAND
 void WindowSurfaceProvider::Initialize(nsWindow* aWidget) {
-  MOZ_ASSERT(aWidget->GetWaylandDisplay(),
-             "We are supposed to have a Wayland display!");
-
   mWidget = aWidget;
   mIsX11Display = false;
 }