removed mozbz#1552590 fix

3 files changed, 1380 insertions, 931 deletions

diff --git a/firefox.spec b/firefox.spec
index eb2c5c0..c4c847c 100644
--- a/firefox.spec
+++ b/firefox.spec
@@ -99,7 +99,7 @@ ExcludeArch: s390x
 Summary:        Mozilla Firefox Web browser
 Name:           firefox
 Version:        67.0
-Release:        5%{?pre_tag}%{?dist}
+Release:        4%{?pre_tag}%{?dist}
 URL:            https://www.mozilla.org/firefox/
 License:        MPLv1.1 or GPLv2+ or LGPLv2+
 Source0:        https://archive.mozilla.org/pub/firefox/releases/%{version}%{?pre_version}/source/firefox-%{version}%{?pre_version}.source.tar.xz
@@ -163,6 +163,7 @@ Patch579:        mozilla-1468911.patch
 Patch580:        mozilla-1539471.patch
 Patch581:        mozilla-1517205.patch
 Patch582:        mozilla-1508378.patch
+Patch583:        mozilla-1467127.patch
 Patch584:        mozilla-1552590.patch
 
 # PGO/LTO patches
@@ -378,7 +379,8 @@ This package contains results of tests executed during build.
 %patch580 -p1 -b .mozilla-1539471
 %patch581 -p1 -b .mozilla-1517205
 %patch582 -p1 -b .mozilla-1508378
-%patch584 -p1 -b .mozilla-1552590
+#%patch583 -p1 -b .mozilla-1467127
+#%patch584 -p1 -b .mozilla-1552590
 
 # PGO patches
 %patch600 -p1 -b .pgo
@@ -936,9 +938,6 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || :
 #---------------------------------------------------------------------
 
 %changelog
-* Thu May 27 2019 Martin Stransky <stransky@redhat.com> - 67.0-5
-- Added mozbz#1552590 fix.
-
 * Thu May 23 2019 Martin Stransky <stransky@redhat.com> - 67.0-4
 - Added wayland buffer optimization (mozilla#1553747).
 
diff --git a/mozilla-1467127.patch b/mozilla-1467127.patch
new file mode 100644
index 0000000..69a8903
--- /dev/null
+++ b/mozilla-1467127.patch
@@ -0,0 +1,256 @@
+diff --git a/gfx/thebes/gfxPlatform.cpp b/gfx/thebes/gfxPlatform.cpp
+--- a/gfx/thebes/gfxPlatform.cpp
++++ b/gfx/thebes/gfxPlatform.cpp
+@@ -70,6 +70,10 @@
+ #  include "mozilla/gfx/DeviceManagerDx.h"
+ #endif
+ 
++#ifdef MOZ_WAYLAND
++#  include "mozilla/widget/nsWaylandDisplayShutdown.h"
++#endif
++
+ #include "nsGkAtoms.h"
+ #include "gfxPlatformFontList.h"
+ #include "gfxContext.h"
+@@ -1276,6 +1280,9 @@
+       layers::PaintThread::Shutdown();
+     }
+   } else if (XRE_IsParentProcess()) {
++#ifdef MOZ_WAYLAND
++    widget::WaylandDisplayShutdown();
++#endif
+     gfx::VRManagerChild::ShutDown();
+     layers::CompositorManagerChild::Shutdown();
+     layers::ImageBridgeChild::ShutDown();
+diff --git a/widget/gtk/WindowSurfaceWayland.cpp b/widget/gtk/WindowSurfaceWayland.cpp
+--- a/widget/gtk/WindowSurfaceWayland.cpp
++++ b/widget/gtk/WindowSurfaceWayland.cpp
+@@ -144,6 +144,8 @@
+ (wl_buffer/wl_surface).
+ */
+ 
++#define EVENT_LOOP_DELAY (1000 / 240)
++
+ #define BUFFER_BPP 4
+ gfx::SurfaceFormat WindowBackBuffer::mFormat = gfx::SurfaceFormat::B8G8R8A8;
+ 
+diff --git a/widget/gtk/moz.build b/widget/gtk/moz.build
+--- a/widget/gtk/moz.build
++++ b/widget/gtk/moz.build
+@@ -101,6 +101,9 @@
+         'nsWaylandDisplay.cpp',
+         'WindowSurfaceWayland.cpp',
+     ]
++    EXPORTS.mozilla.widget += [
++        'nsWaylandDisplayShutdown.h'
++    ]
+ 
+ if CONFIG['ACCESSIBILITY']:
+     UNIFIED_SOURCES += [
+diff --git a/widget/gtk/nsAppShell.cpp b/widget/gtk/nsAppShell.cpp
+--- a/widget/gtk/nsAppShell.cpp
++++ b/widget/gtk/nsAppShell.cpp
+@@ -27,6 +27,9 @@
+ #include "ScreenHelperGTK.h"
+ #include "HeadlessScreenHelper.h"
+ #include "mozilla/widget/ScreenManager.h"
++#ifdef MOZ_WAYLAND
++#  include "nsWaylandDisplay.h"
++#endif
+ 
+ using mozilla::LazyLogModule;
+ using mozilla::Unused;
+@@ -267,5 +270,9 @@
+ }
+ 
+ bool nsAppShell::ProcessNextNativeEvent(bool mayWait) {
+-  return g_main_context_iteration(nullptr, mayWait);
++  bool ret = g_main_context_iteration(nullptr, mayWait);
++#ifdef MOZ_WAYLAND
++  WaylandDispatchDisplays();
++#endif
++  return ret;
+ }
+diff --git a/widget/gtk/nsWaylandDisplay.h b/widget/gtk/nsWaylandDisplay.h
+--- a/widget/gtk/nsWaylandDisplay.h
++++ b/widget/gtk/nsWaylandDisplay.h
+@@ -14,10 +14,6 @@
+ 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 {
+@@ -25,9 +21,10 @@
+   explicit nsWaylandDisplay(wl_display* aDisplay);
+   virtual ~nsWaylandDisplay();
+ 
+-  bool DisplayLoop();
++  bool DispatchEventQueue();
+   bool Matches(wl_display* aDisplay);
+ 
++  MessageLoop* GetDispatcherThreadLoop() { return mDispatcherThreadLoop; }
+   wl_display* GetDisplay() { return mDisplay; };
+   wl_event_queue* GetEventQueue() { return mEventQueue; };
+   wl_subcompositor* GetSubcompositor(void) { return mSubcompositor; };
+@@ -47,7 +44,10 @@
+   void SetPrimarySelectionDeviceManager(
+       gtk_primary_selection_device_manager* aPrimarySelectionDeviceManager);
+ 
++  void Shutdown();
++
+  private:
++  MessageLoop* mDispatcherThreadLoop;
+   PRThread* mThreadId;
+   wl_display* mDisplay;
+   wl_event_queue* mEventQueue;
+@@ -59,6 +59,7 @@
+   wl_registry* mRegistry;
+ };
+ 
++void WaylandDispatchDisplays();
+ nsWaylandDisplay* WaylandDisplayGet(GdkDisplay* aGdkDisplay = nullptr);
+ 
+ }  // namespace widget
+diff --git a/widget/gtk/nsWaylandDisplay.cpp b/widget/gtk/nsWaylandDisplay.cpp
+--- a/widget/gtk/nsWaylandDisplay.cpp
++++ b/widget/gtk/nsWaylandDisplay.cpp
+@@ -21,6 +21,15 @@
+ static nsWaylandDisplay *gWaylandDisplays[MAX_DISPLAY_CONNECTIONS];
+ static StaticMutex gWaylandDisplaysMutex;
+ 
++void WaylandDisplayShutdown() {
++  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
++  for (auto &display : gWaylandDisplays) {
++    if (display) {
++      display->Shutdown();
++    }
++  }
++}
++
+ static void ReleaseDisplaysAtExit() {
+   for (int i = 0; i < MAX_DISPLAY_CONNECTIONS; i++) {
+     delete gWaylandDisplays[i];
+@@ -28,6 +37,10 @@
+   }
+ }
+ 
++static void DispatchDisplay(nsWaylandDisplay *aDisplay) {
++  aDisplay->DispatchEventQueue();
++}
++
+ // 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.
+@@ -35,7 +48,15 @@
+ // 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);
++void WaylandDispatchDisplays() {
++  StaticMutexAutoLock lock(gWaylandDisplaysMutex);
++  for (auto &display : gWaylandDisplays) {
++    if (display && display->GetDispatcherThreadLoop()) {
++      display->GetDispatcherThreadLoop()->PostTask(NewRunnableFunction(
++          "WaylandDisplayDispatch", &DispatchDisplay, display));
++    }
++  }
++}
+ 
+ // Get WaylandDisplay for given wl_display and actual calling thread.
+ static nsWaylandDisplay *WaylandDisplayGetLocked(GdkDisplay *aGdkDisplay,
+@@ -73,27 +94,6 @@
+   return WaylandDisplayGetLocked(aGdkDisplay, 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) {
+@@ -158,7 +158,7 @@
+ static const struct wl_registry_listener registry_listener = {
+     global_registry_handler, global_registry_remover};
+ 
+-bool nsWaylandDisplay::DisplayLoop() {
++bool nsWaylandDisplay::DispatchEventQueue() {
+   wl_display_dispatch_queue_pending(mDisplay, mEventQueue);
+   return true;
+ }
+@@ -168,7 +168,8 @@
+ }
+ 
+ nsWaylandDisplay::nsWaylandDisplay(wl_display *aDisplay)
+-    : mThreadId(PR_GetCurrentThread()),
++    : mDispatcherThreadLoop(nullptr),
++      mThreadId(PR_GetCurrentThread()),
+       mDisplay(aDisplay),
+       mEventQueue(nullptr),
+       mDataDeviceManager(nullptr),
+@@ -186,15 +187,16 @@
+     wl_display_roundtrip(mDisplay);
+     wl_display_roundtrip(mDisplay);
+   } else {
++    mDispatcherThreadLoop = MessageLoop::current();
+     mEventQueue = wl_display_create_queue(mDisplay);
+-    MessageLoop::current()->PostTask(NewRunnableFunction(
+-        "WaylandDisplayLoop", &WaylandDisplayLoop, mDisplay));
+     wl_proxy_set_queue((struct wl_proxy *)mRegistry, mEventQueue);
+     wl_display_roundtrip_queue(mDisplay, mEventQueue);
+     wl_display_roundtrip_queue(mDisplay, mEventQueue);
+   }
+ }
+ 
++void nsWaylandDisplay::Shutdown() { mDispatcherThreadLoop = nullptr; }
++
+ nsWaylandDisplay::~nsWaylandDisplay() {
+   // Owned by Gtk+, we don't need to release
+   mDisplay = nullptr;
+diff --git a/widget/gtk/nsWaylandDisplayShutdown.h b/widget/gtk/nsWaylandDisplayShutdown.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/nsWaylandDisplayShutdown.h
+@@ -0,0 +1,19 @@
++/* -*- 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_DISPLAY_SHUTDOWN_H__
++#define __MOZ_WAYLAND_DISPLAY_SHUTDOWN_H__
++
++namespace mozilla {
++namespace widget {
++
++void WaylandDisplayShutdown();
++
++}  // namespace widget
++}  // namespace mozilla
++
++#endif  // __MOZ_WAYLAND_DISPLAY_SHUTDOWN_H__
+
diff --git a/mozilla-1552590.patch b/mozilla-1552590.patch
index 4726c20..58d5b18 100644
--- a/mozilla-1552590.patch
+++ b/mozilla-1552590.patch
@@ -1,25 +1,13 @@
-diff -up firefox-67.0/gfx/2d/moz.build.mozilla-1552590 firefox-67.0/gfx/2d/moz.build
---- firefox-67.0/gfx/2d/moz.build.mozilla-1552590	2019-05-17 02:34:18.000000000 +0200
-+++ firefox-67.0/gfx/2d/moz.build	2019-05-27 12:15:32.030414339 +0200
-@@ -260,3 +260,15 @@ if CONFIG['MOZ_ENABLE_SKIA_GPU']:
-     LOCAL_INCLUDES += [
-         '/gfx/skia/skia/src/gpu',
-     ]
-+
-+#if CONFIG['MOZ_WAYLAND'] and CONFIG['HAVE_LIBDRM']:
-+if CONFIG['HAVE_LIBDRM']:
-+    SOURCES += [
-+        'WaylandDMABufSurface.cpp',
-+    ]
-+    EXPORTS.mozilla.gfx += [
-+        'WaylandDMABufSurface.h',
-+    ]
-+    CFLAGS += CONFIG['TK_CFLAGS']
-+    CXXFLAGS += CONFIG['TK_CFLAGS']
-+
-diff -up firefox-67.0/gfx/2d/WaylandDMABufSurface.cpp.mozilla-1552590 firefox-67.0/gfx/2d/WaylandDMABufSurface.cpp
---- firefox-67.0/gfx/2d/WaylandDMABufSurface.cpp.mozilla-1552590	2019-05-27 12:15:32.030414339 +0200
-+++ firefox-67.0/gfx/2d/WaylandDMABufSurface.cpp	2019-05-27 12:15:32.030414339 +0200
+changeset:   474982:24c0dda573b3
+parent:      474915:839cdad764d7
+user:        Martin Stransky <stransky@redhat.com>
+date:        Fri May 17 11:24:33 2019 +0200
+summary:     Implement dmabuf surfaces
+
+diff --git a/gfx/2d/WaylandDMABufSurface.cpp b/gfx/2d/WaylandDMABufSurface.cpp
+new file mode 100644
+--- /dev/null
++++ b/gfx/2d/WaylandDMABufSurface.cpp
 @@ -0,0 +1,274 @@
 +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 +/* vim: set ts=8 sts=2 et sw=2 tw=80: */
@@ -295,9 +283,10 @@ diff -up firefox-67.0/gfx/2d/WaylandDMABufSurface.cpp.mozilla-1552590 firefox-67
 +  memset(destData, 0, GetHeight() * destStride);
 +  Unmap();
 +}
-diff -up firefox-67.0/gfx/2d/WaylandDMABufSurface.h.mozilla-1552590 firefox-67.0/gfx/2d/WaylandDMABufSurface.h
---- firefox-67.0/gfx/2d/WaylandDMABufSurface.h.mozilla-1552590	2019-05-27 12:15:32.030414339 +0200
-+++ firefox-67.0/gfx/2d/WaylandDMABufSurface.h	2019-05-27 12:15:32.030414339 +0200
+diff --git a/gfx/2d/WaylandDMABufSurface.h b/gfx/2d/WaylandDMABufSurface.h
+new file mode 100644
+--- /dev/null
++++ b/gfx/2d/WaylandDMABufSurface.h
 @@ -0,0 +1,73 @@
 +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 +/* vim: set ts=8 sts=2 et sw=2 tw=80: */
@@ -372,10 +361,39 @@ diff -up firefox-67.0/gfx/2d/WaylandDMABufSurface.h.mozilla-1552590 firefox-67.0
 +};
 +
 +#endif
-diff -up firefox-67.0/modules/libpref/init/all.js.mozilla-1552590 firefox-67.0/modules/libpref/init/all.js
---- firefox-67.0/modules/libpref/init/all.js.mozilla-1552590	2019-05-17 02:33:43.000000000 +0200
-+++ firefox-67.0/modules/libpref/init/all.js	2019-05-27 12:15:32.031414339 +0200
-@@ -5138,6 +5138,11 @@ pref("widget.chrome.allow-gtk-dark-theme
+diff --git a/gfx/2d/moz.build b/gfx/2d/moz.build
+--- a/gfx/2d/moz.build
++++ b/gfx/2d/moz.build
+@@ -255,8 +255,20 @@ if CONFIG['MOZ_ENABLE_SKIA']:
+         '/gfx/skia/skia/include/private',
+         '/gfx/skia/skia/src/core',
+         '/gfx/skia/skia/src/image',
+     ]
+ if CONFIG['MOZ_ENABLE_SKIA_GPU']:
+     LOCAL_INCLUDES += [
+         '/gfx/skia/skia/src/gpu',
+     ]
++
++#if CONFIG['MOZ_WAYLAND'] and CONFIG['HAVE_LIBDRM']:
++if CONFIG['HAVE_LIBDRM']:
++    SOURCES += [
++        'WaylandDMABufSurface.cpp',
++    ]
++    EXPORTS.mozilla.gfx += [
++        'WaylandDMABufSurface.h',
++    ]
++    CFLAGS += CONFIG['TK_CFLAGS']
++    CXXFLAGS += CONFIG['TK_CFLAGS']
++
+diff --git a/modules/libpref/init/all.js b/modules/libpref/init/all.js
+--- a/modules/libpref/init/all.js
++++ b/modules/libpref/init/all.js
+@@ -5091,16 +5091,21 @@ pref("gfx.apitrace.enabled",false);
+ 
+ #ifdef MOZ_X11
+ #ifdef MOZ_WIDGET_GTK
+ pref("gfx.xrender.enabled",false);
+ pref("widget.chrome.allow-gtk-dark-theme", false);
  pref("widget.content.allow-gtk-dark-theme", false);
  #endif
  #endif
@@ -387,10 +405,20 @@ diff -up firefox-67.0/modules/libpref/init/all.js.mozilla-1552590 firefox-67.0/m
  
  pref("widget.window-transforms.disabled", false);
  
-diff -up firefox-67.0/toolkit/moz.configure.mozilla-1552590 firefox-67.0/toolkit/moz.configure
---- firefox-67.0/toolkit/moz.configure.mozilla-1552590	2019-05-27 12:15:31.992414348 +0200
-+++ firefox-67.0/toolkit/moz.configure	2019-05-27 12:15:32.031414339 +0200
-@@ -265,6 +265,14 @@ def wayland_headers(wayland, toolkit_gtk
+ #ifdef XP_WIN
+ // Whether to disable the automatic detection and use of direct2d.
+ pref("gfx.direct2d.disabled", false);
+ 
+ // Whether to attempt to enable Direct2D regardless of automatic detection or
+diff --git a/toolkit/moz.configure b/toolkit/moz.configure
+--- a/toolkit/moz.configure
++++ b/toolkit/moz.configure
+@@ -260,16 +260,24 @@ def wayland_headers(wayland, toolkit_gtk
+     if toolkit_gtk and artifacts:
+         return True
+     return wayland
+ 
+ 
  set_config('MOZ_WAYLAND', depends_if(wayland_headers)(lambda _: True))
  set_define('MOZ_WAYLAND', depends_if(wayland_headers)(lambda _: True))
  
@@ -405,61 +433,939 @@ diff -up firefox-67.0/toolkit/moz.configure.mozilla-1552590 firefox-67.0/toolkit
  # GL Provider
  # ==============================================================
  option('--with-gl-provider', nargs=1, help='Set GL provider backend type')
-diff -up firefox-67.0/widget/gtk/moz.build.mozilla-1552590 firefox-67.0/widget/gtk/moz.build
---- firefox-67.0/widget/gtk/moz.build.mozilla-1552590	2019-05-17 02:34:02.000000000 +0200
-+++ firefox-67.0/widget/gtk/moz.build	2019-05-27 12:15:32.031414339 +0200
-@@ -101,6 +101,9 @@ if CONFIG['MOZ_WAYLAND']:
+ 
+ @depends('--with-gl-provider')
+ def gl_provider(value):
+     if value:
+         return value[0]
+diff --git a/widget/gtk/WindowSurfaceWayland.cpp b/widget/gtk/WindowSurfaceWayland.cpp
+--- a/widget/gtk/WindowSurfaceWayland.cpp
++++ b/widget/gtk/WindowSurfaceWayland.cpp
+@@ -30,16 +30,19 @@ extern mozilla::LazyLogModule gWidgetWay
+     MOZ_LOG(gWidgetWaylandLog, mozilla::LogLevel::Debug, args)
+ #else
+ #  define LOGWAYLAND(args)
+ #endif /* MOZ_LOGGING */
+ 
+ namespace mozilla {
+ namespace widget {
+ 
++bool WindowSurfaceWayland::mUseDMABuf = false;
++bool WindowSurfaceWayland::mUseDMABufInitialized = false;
++
+ /*
+   Wayland multi-thread rendering scheme
+ 
+   Every rendering thread (main thread, compositor thread) contains its own
+   nsWaylandDisplay object connected to Wayland compositor (Mutter, Weston, etc.)
+ 
+   WindowSurfaceWayland implements WindowSurface class and draws nsWindow by
+   WindowSurface interface (Lock, Commit) to screen through nsWaylandDisplay.
+@@ -255,120 +258,183 @@ WaylandShmPool::~WaylandShmPool() {
+ 
+ static void buffer_release(void* data, wl_buffer* buffer) {
+   auto surface = reinterpret_cast<WindowBackBuffer*>(data);
+   surface->Detach(buffer);
+ }
+ 
+ static const struct wl_buffer_listener buffer_listener = {buffer_release};
+ 
+-void WindowBackBuffer::Create(int aWidth, int aHeight) {
++void WindowBackBufferShm::Create(int aWidth, int aHeight) {
+   MOZ_ASSERT(!IsAttached(), "We can't resize attached buffers.");
+ 
+   int newBufferSize = aWidth * aHeight * BUFFER_BPP;
+   mShmPool.Resize(newBufferSize);
+ 
+   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,
+-                     mWaylandDisplay->GetEventQueue());
++                     GetWaylandDisplay()->GetEventQueue());
+   wl_buffer_add_listener(mWaylandBuffer, &buffer_listener, this);
+ 
+   mWidth = aWidth;
+   mHeight = aHeight;
+ 
+   LOGWAYLAND((
+       "%s [%p] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__, (void*)this,
+       (void*)mWaylandBuffer,
+       mWaylandBuffer ? wl_proxy_get_id((struct wl_proxy*)mWaylandBuffer) : -1));
+ }
+ 
+-void WindowBackBuffer::Release() {
++void WindowBackBufferShm::Release() {
+   LOGWAYLAND(("%s [%p]\n", __PRETTY_FUNCTION__, (void*)this));
+ 
+   wl_buffer_destroy(mWaylandBuffer);
+   mWidth = mHeight = 0;
+ }
+ 
+-void WindowBackBuffer::Clear() {
++void WindowBackBufferShm::Clear() {
+   memset(mShmPool.GetImageData(), 0, mHeight * mWidth * BUFFER_BPP);
+ }
+ 
+-WindowBackBuffer::WindowBackBuffer(nsWaylandDisplay* aWaylandDisplay,
+-                                   int aWidth, int aHeight)
+-    : mShmPool(aWaylandDisplay, aWidth * aHeight * BUFFER_BPP),
++WindowBackBufferShm::WindowBackBufferShm(nsWaylandDisplay* aWaylandDisplay,
++                                         int aWidth, int aHeight)
++    : WindowBackBuffer(aWaylandDisplay),
++      mShmPool(aWaylandDisplay, aWidth * aHeight * BUFFER_BPP),
+       mWaylandBuffer(nullptr),
+       mWidth(aWidth),
+       mHeight(aHeight),
+-      mAttached(false),
+-      mWaylandDisplay(aWaylandDisplay) {
++      mAttached(false) {
+   Create(aWidth, aHeight);
+ }
+ 
+-WindowBackBuffer::~WindowBackBuffer() { Release(); }
++WindowBackBufferShm::~WindowBackBufferShm() { Release(); }
+ 
+-bool WindowBackBuffer::Resize(int aWidth, int aHeight) {
++bool WindowBackBufferShm::Resize(int aWidth, int aHeight) {
+   if (aWidth == mWidth && aHeight == mHeight) return true;
+ 
+   LOGWAYLAND(
+       ("%s [%p] %d %d\n", __PRETTY_FUNCTION__, (void*)this, aWidth, aHeight));
+ 
+   Release();
+   Create(aWidth, aHeight);
+ 
+   return (mWaylandBuffer != nullptr);
+ }
+ 
+ void WindowBackBuffer::Attach(wl_surface* aSurface) {
+-  LOGWAYLAND((
+-      "%s [%p] wl_surface %p ID %d wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
+-      (void*)this, (void*)aSurface,
+-      aSurface ? wl_proxy_get_id((struct wl_proxy*)aSurface) : -1,
+-      (void*)mWaylandBuffer,
+-      mWaylandBuffer ? wl_proxy_get_id((struct wl_proxy*)mWaylandBuffer) : -1));
++  LOGWAYLAND(
++      ("%s [%p] wl_surface %p ID %d wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
++       (void*)this, (void*)aSurface,
++       aSurface ? wl_proxy_get_id((struct wl_proxy*)aSurface) : -1,
++       (void*)GetWlBuffer(),
++       GetWlBuffer() ? wl_proxy_get_id((struct wl_proxy*)GetWlBuffer()) : -1));
+ 
+-  wl_surface_attach(aSurface, mWaylandBuffer, 0, 0);
++  wl_surface_attach(aSurface, GetWlBuffer(), 0, 0);
+   wl_surface_commit(aSurface);
+-  wl_display_flush(mWaylandDisplay->GetDisplay());
+-  mAttached = true;
++  wl_display_flush(GetWaylandDisplay()->GetDisplay());
++  SetAttached();
+ }
+ 
+-void WindowBackBuffer::Detach(wl_buffer* aBuffer) {
++void WindowBackBufferShm::Detach(wl_buffer* aBuffer) {
+   LOGWAYLAND(("%s [%p] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__, (void*)this,
+               (void*)aBuffer,
+               aBuffer ? wl_proxy_get_id((struct wl_proxy*)aBuffer) : -1));
+ 
+   mAttached = false;
+ }
+ 
+-bool WindowBackBuffer::SetImageDataFromBuffer(
++bool WindowBackBufferShm::SetImageDataFromBuffer(
+     class WindowBackBuffer* aSourceBuffer) {
+-  if (!IsMatchingSize(aSourceBuffer)) {
+-    Resize(aSourceBuffer->mWidth, aSourceBuffer->mHeight);
++  auto sourceBuffer = static_cast<class WindowBackBufferShm*>(aSourceBuffer);
++  if (!IsMatchingSize(sourceBuffer)) {
++    Resize(sourceBuffer->mWidth, sourceBuffer->mHeight);
+   }
+ 
+   mShmPool.SetImageDataFromPool(
+-      &aSourceBuffer->mShmPool,
+-      aSourceBuffer->mWidth * aSourceBuffer->mHeight * BUFFER_BPP);
++      &sourceBuffer->mShmPool,
++      sourceBuffer->mWidth * sourceBuffer->mHeight * BUFFER_BPP);
+   return true;
+ }
+ 
+-already_AddRefed<gfx::DrawTarget> WindowBackBuffer::Lock() {
++already_AddRefed<gfx::DrawTarget> WindowBackBufferShm::Lock() {
+   LOGWAYLAND((
+       "%s [%p] [%d x %d] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
+       (void*)this, mWidth, mHeight, (void*)mWaylandBuffer,
+       mWaylandBuffer ? wl_proxy_get_id((struct wl_proxy*)mWaylandBuffer) : -1));
+ 
+   gfx::IntSize lockSize(mWidth, mHeight);
+   return gfxPlatform::CreateDrawTargetForData(
+       static_cast<unsigned char*>(mShmPool.GetImageData()), lockSize,
+-      BUFFER_BPP * mWidth, mFormat);
++      BUFFER_BPP * mWidth, GetSurfaceFormat());
++}
++
++#ifdef HAVE_LIBDRM
++WindowBackBufferDMABuf::WindowBackBufferDMABuf(
++    nsWaylandDisplay* aWaylandDisplay, int aWidth, int aHeight)
++    : WindowBackBuffer(aWaylandDisplay) {
++  mDMAbufSurface.Create(aWidth, aHeight);
++}
++
++WindowBackBufferDMABuf::~WindowBackBufferDMABuf() { mDMAbufSurface.Release(); }
++
++already_AddRefed<gfx::DrawTarget> WindowBackBufferDMABuf::Lock() {
++  LOGWAYLAND(
++      ("%s [%p] [%d x %d] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
++       (void*)this, GetWidth(), GetHeight(), (void*)GetWlBuffer(),
++       GetWlBuffer() ? wl_proxy_get_id((struct wl_proxy*)GetWlBuffer()) : -1));
++
++  uint32_t stride;
++  void* pixels = mDMAbufSurface.Map(&stride);
++  gfx::IntSize lockSize(GetWidth(), GetHeight());
++  return gfxPlatform::CreateDrawTargetForData(
++      static_cast<unsigned char*>(pixels), lockSize, stride,
++      GetSurfaceFormat());
++}
++
++void WindowBackBufferDMABuf::Unlock() { mDMAbufSurface.Unmap(); }
++
++bool WindowBackBufferDMABuf::IsAttached() {
++  return mDMAbufSurface.WLBufferIsAttached();
+ }
+ 
++void WindowBackBufferDMABuf::SetAttached() {
++  return mDMAbufSurface.WLBufferSetAttached();
++}
++
++int WindowBackBufferDMABuf::GetWidth() { return mDMAbufSurface.GetWidth(); }
++
++int WindowBackBufferDMABuf::GetHeight() { return mDMAbufSurface.GetHeight(); }
++
++wl_buffer* WindowBackBufferDMABuf::GetWlBuffer() {
++  return mDMAbufSurface.GetWLBuffer();
++}
++
++bool WindowBackBufferDMABuf::IsLocked() { return mDMAbufSurface.IsMapped(); }
++
++bool WindowBackBufferDMABuf::Resize(int aWidth, int aHeight) {
++  return mDMAbufSurface.Resize(aWidth, aHeight);
++}
++
++bool WindowBackBufferDMABuf::SetImageDataFromBuffer(
++    class WindowBackBuffer* aSourceBuffer) {
++  WindowBackBufferDMABuf* source =
++      static_cast<WindowBackBufferDMABuf*>(aSourceBuffer);
++  mDMAbufSurface.CopyFrom(&source->mDMAbufSurface);
++  return true;
++}
++
++void WindowBackBufferDMABuf::Detach(wl_buffer* aBuffer) {
++  mDMAbufSurface.WLBufferDetach();
++}
++
++void WindowBackBufferDMABuf::Clear() { mDMAbufSurface.Clear(); }
++#endif
++
+ static void frame_callback_handler(void* data, struct wl_callback* callback,
+                                    uint32_t time) {
+   auto surface = reinterpret_cast<WindowSurfaceWayland*>(data);
+   surface->FrameCallbackHandler();
+ 
+   gfxPlatformGtk::GetPlatform()->SetWaylandLastVsync(time);
+ }
+ 
+@@ -412,23 +478,60 @@ WindowSurfaceWayland::~WindowSurfaceWayl
+ 
+   for (int i = 0; i < BACK_BUFFER_NUM; i++) {
+     if (mBackupBuffer[i]) {
+       delete mBackupBuffer[i];
+     }
+   }
+ }
+ 
+-WindowBackBuffer* WindowSurfaceWayland::GetWaylandBufferToDraw(int aWidth,
+-                                                               int aHeight) {
++bool WindowSurfaceWayland::UseDMABufBackend() {
++  if (!mUseDMABufInitialized) {
++#ifdef HAVE_LIBDRM
++    if (WaylandDMABufSurface::IsAvailable()) {
++      mUseDMABuf =
++          Preferences::GetBool("gfx.wayland_dmabuf_backend.enabled", false);
++    }
++#endif
++    mUseDMABufInitialized = true;
++  }
++  return mUseDMABuf;
++}
++
++WindowBackBuffer* WindowSurfaceWayland::CreateWaylandBuffer(int aWidth,
++                                                            int aHeight) {
++  if (UseDMABufBackend()) {
++    static bool sDMABufBufferCreated = false;
++    WindowBackBuffer* buffer =
++        new WindowBackBufferDMABuf(mWaylandDisplay, aWidth, aHeight);
++    if (buffer) {
++      sDMABufBufferCreated = true;
++      return buffer;
++    }
++    // If this is the first failure and there's no dmabuf already active
++    // we can safely fallback to Shm. Otherwise we can't mix DMAbuf and
++    // SHM buffers so just fails now.
++    if (sDMABufBufferCreated) {
++      NS_WARNING("Failed to allocate DMABuf buffer!");
++      return nullptr;
++    } else {
++      NS_WARNING("Wayland DMABuf failed, switched back to Shm backend!");
++      mUseDMABuf = false;
++    }
++  }
++  return new WindowBackBufferShm(mWaylandDisplay, aWidth, aHeight);
++}
++
++WindowBackBuffer* WindowSurfaceWayland::GetWaylandBufferToDraw(
++    int aWidth, int aHeight, bool aFullScreenUpdate, bool aNoBackBufferCopy) {
+   if (!mWaylandBuffer) {
+     LOGWAYLAND(("%s [%p] Create [%d x %d]\n", __PRETTY_FUNCTION__, (void*)this,
+                 aWidth, aHeight));
+ 
+-    mWaylandBuffer = new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
++    mWaylandBuffer = CreateWaylandBuffer(aWidth, aHeight);
+     mWaitToFullScreenUpdate = true;
+     return mWaylandBuffer;
+   }
+ 
+   if (!mWaylandBuffer->IsAttached()) {
+     if (!mWaylandBuffer->IsMatchingSize(aWidth, aHeight)) {
+       mWaylandBuffer->Resize(aWidth, aHeight);
+       // There's a chance that scale factor has been changed
+@@ -444,75 +547,89 @@ WindowBackBuffer* WindowSurfaceWayland::
+   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);
++      mBackupBuffer[availableBuffer] = CreateWaylandBuffer(aWidth, aHeight);
+       break;
+     }
+ 
+     if (!mBackupBuffer[availableBuffer]->IsAttached()) {
+       break;
+     }
+   }
+ 
+   if (MOZ_UNLIKELY(availableBuffer == BACK_BUFFER_NUM)) {
+     LOGWAYLAND(("%s [%p] No drawing buffer available!\n", __PRETTY_FUNCTION__,
+                 (void*)this));
+     NS_WARNING("No drawing buffer available");
+     return nullptr;
+   }
+ 
++  bool bufferFlip = mWaylandBuffer->IsMatchingSize(aWidth, aHeight);
++  if (bufferFlip && aNoBackBufferCopy && !aFullScreenUpdate) {
++    LOGWAYLAND(("%s [%p] Delayed hard copy from old buffer [%d x %d]\n",
++                __PRETTY_FUNCTION__, (void*)this, aWidth, aHeight));
++    return nullptr;
++  }
++
+   WindowBackBuffer* lastWaylandBuffer = mWaylandBuffer;
+   mWaylandBuffer = mBackupBuffer[availableBuffer];
+   mBackupBuffer[availableBuffer] = lastWaylandBuffer;
+ 
+-  if (lastWaylandBuffer->IsMatchingSize(aWidth, aHeight)) {
+-    LOGWAYLAND(("%s [%p] Copy from old buffer [%d x %d]\n", __PRETTY_FUNCTION__,
+-                (void*)this, aWidth, aHeight));
++  if (bufferFlip) {
+     // 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.
+-    mWaylandBuffer->SetImageDataFromBuffer(lastWaylandBuffer);
++    // existing data to the new buffer if we don't do fullscreen redraw.
++    if (!aFullScreenUpdate) {
++      LOGWAYLAND(("%s [%p] Copy from old buffer [%d x %d]\n",
++                  __PRETTY_FUNCTION__, (void*)this, aWidth, aHeight));
++      mWaylandBuffer->SetImageDataFromBuffer(lastWaylandBuffer);
++    }
+     // When buffer switches we need to damage whole screen
+     // (https://bugzilla.redhat.com/show_bug.cgi?id=1418260)
+     mWaylandBufferFullScreenDamage = true;
+   } else {
+     LOGWAYLAND(("%s [%p] Resize to [%d x %d]\n", __PRETTY_FUNCTION__,
+                 (void*)this, aWidth, aHeight));
+     // Former buffer has different size from the new request. Only resize
+     // the new buffer and leave gecko to render new whole content.
+     mWaylandBuffer->Resize(aWidth, aHeight);
+     mWaitToFullScreenUpdate = true;
+   }
+ 
+   return mWaylandBuffer;
+ }
+ 
+ already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockWaylandBuffer(
+-    int aWidth, int aHeight, bool aClearBuffer) {
+-  WindowBackBuffer* buffer = GetWaylandBufferToDraw(aWidth, aHeight);
++    int aWidth, int aHeight, bool aClearBuffer, bool aFullScreenUpdate,
++    bool aNoBackBufferCopy) {
++  WindowBackBuffer* buffer = GetWaylandBufferToDraw(
++      aWidth, aHeight, aFullScreenUpdate, aNoBackBufferCopy);
+   if (!buffer) {
+-    NS_WARNING(
+-        "WindowSurfaceWayland::LockWaylandBuffer(): No buffer available");
++    if (!aNoBackBufferCopy) {
++      NS_WARNING(
++          "WindowSurfaceWayland::LockWaylandBuffer(): No buffer available");
++    }
+     return nullptr;
+   }
+ 
+   if (aClearBuffer) {
+     buffer->Clear();
+   }
+ 
+   return buffer->Lock();
+ }
+ 
++void WindowSurfaceWayland::UnlockWaylandBuffer() { mWaylandBuffer->Unlock(); }
++
+ 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()) {
+@@ -552,20 +669,28 @@ already_AddRefed<gfx::DrawTarget> Window
+ 
+   // 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 there's any pending image commit scratch them as we're going
++    // to redraw the whole sceen anyway.
++    mDelayedImageCommits.Clear();
++
++    bool needsClear = mWindow->WaylandSurfaceNeedsClear();
++    RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(
++        screenRect.width, screenRect.height, needsClear,
++        /* aFullScreenUpdate */ true, /* aNoBackBufferCopy */ true);
+     if (dt) {
++      if (needsClear) {
++        mWindow->WaylandSurfaceCleared();
++      }
+       // When we have a request to update whole screen at once
+       // (surface was created, resized or changed somehow)
+       // we also need update scale factor of the screen.
+       if (mWaitToFullScreenUpdate) {
+         mWaitToFullScreenUpdate = false;
+         mNeedScaleFactorUpdate = true;
+       }
+       return dt.forget();
+@@ -574,52 +699,94 @@ already_AddRefed<gfx::DrawTarget> Window
+     // 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);
+ }
+ 
++void WindowImageSurface::Draw(gfx::SourceSurface* aSurface,
++                              gfx::DrawTarget* aDest,
++                              const LayoutDeviceIntRegion& aRegion) {
++  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());
++    }
++    aDest->PushDeviceSpaceClipRects(rects.Elements(), rects.Length());
++  }
++
++  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
++  gfx::Rect rect(bounds);
++  aDest->DrawSurface(aSurface, rect, rect);
++
++  if (numRects != 1) {
++    aDest->PopClip();
++  }
++}
++
++void WindowImageSurface::Draw(gfx::DrawTarget* aDest,
++                              LayoutDeviceIntRegion& aWaylandBufferDamage) {
++  Draw(mSurface.get(), aDest, mUpdateRegion);
++  aWaylandBufferDamage.OrWith(mUpdateRegion);
++}
++
++WindowImageSurface::WindowImageSurface(
++    gfx::SourceSurface* aSurface, const LayoutDeviceIntRegion& aUpdateRegion)
++    : mSurface(aSurface), mUpdateRegion(aUpdateRegion){};
++
++void WindowSurfaceWayland::DrawDelayedImageCommits(
++    gfx::DrawTarget* aDrawTarget, LayoutDeviceIntRegion& aWaylandBufferDamage) {
++  for (unsigned int i = 0; i < mDelayedImageCommits.Length(); i++) {
++    mDelayedImageCommits[i].Draw(aDrawTarget, aWaylandBufferDamage);
++  }
++  mDelayedImageCommits.Clear();
++}
++
+ bool WindowSurfaceWayland::CommitImageSurfaceToWaylandBuffer(
+-    const LayoutDeviceIntRegion& aRegion) {
++    const LayoutDeviceIntRegion& aRegion,
++    LayoutDeviceIntRegion& aWaylandBufferDamage) {
+   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) {
++  if (!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());
++  bool needsClear = mWindow->WaylandSurfaceNeedsClear();
++  RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(
++      screenRect.width, screenRect.height, needsClear,
++      /* fullscreenDrawing */ false, /* aNoBackBufferCopy */ true);
++  if (dt) {
++    if (needsClear) {
++      mWindow->WaylandSurfaceCleared();
+     }
+-    dt->PushDeviceSpaceClipRects(rects.Elements(), rects.Length());
+-  }
+-
+-  dt->DrawSurface(surf, rect, rect);
+-
+-  if (numRects != 1) {
+-    dt->PopClip();
++    // Draw any delayed image commits first
++    DrawDelayedImageCommits(dt, aWaylandBufferDamage);
++    WindowImageSurface::Draw(surf, dt, aRegion);
++    // Submit all drawing to final Wayland buffer upload
++    aWaylandBufferDamage.OrWith(aRegion);
++    UnlockWaylandBuffer();
++  } else {
++    mDelayedImageCommits.AppendElement(WindowImageSurface(surf, aRegion));
++    return false;
+   }
+ 
+   return true;
+ }
+ 
+ static void WaylandBufferDelayCommitHandler(WindowSurfaceWayland** aSurface) {
+   if (*aSurface) {
+     (*aSurface)->DelayedCommitHandler();
+@@ -643,16 +810,34 @@ void WindowSurfaceWayland::CalcRectScale
+ 
+ void WindowSurfaceWayland::CommitWaylandBuffer() {
+   MOZ_ASSERT(mPendingCommit, "Committing empty surface!");
+ 
+   if (mWaitToFullScreenUpdate) {
+     return;
+   }
+ 
++  if (!mDrawToWaylandBufferDirectly) {
++    // There's some cached drawings - try to flush them now.
++    LayoutDeviceIntRect screenRect = mWindow->GetBounds();
++    bool needsClear = mWindow->WaylandSurfaceNeedsClear();
++    RefPtr<gfx::DrawTarget> dt =
++        LockWaylandBuffer(screenRect.width, screenRect.height, needsClear,
++                          /* fullscreenInvalidate */ false,
++                          /* aNoBackBufferCopy */ true);
++    if (dt) {
++      if (needsClear) {
++        mWindow->WaylandSurfaceCleared();
++      }
++      DrawDelayedImageCommits(dt, mWaylandBufferDamage);
++      UnlockWaylandBuffer();
++      mDrawToWaylandBufferDirectly = true;
++    }
++  }
++
+   wl_surface* waylandSurface = mWindow->GetWaylandSurface();
+   if (!waylandSurface) {
+     // 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!");
+ 
+@@ -735,24 +920,31 @@ void WindowSurfaceWayland::Commit(const 
+     gfx::IntSize lockSize(bounds.XMost(), bounds.YMost());
+ 
+     LOGWAYLAND(("%s [%p] lockSize [%d x %d] screenSize [%d x %d]\n",
+                 __PRETTY_FUNCTION__, (void*)this, lockSize.width,
+                 lockSize.height, screenRect.width, lockSize.height));
+   }
+ #endif
+ 
+-  // 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);
++  if (mDrawToWaylandBufferDirectly) {
++    MOZ_ASSERT(mWaylandBuffer->IsLocked());
++    // If we're not at fullscreen damage add drawing area from aInvalidRegion
++    if (!mWaylandBufferFullScreenDamage) {
++      mWaylandBufferDamage.OrWith(aInvalidRegion);
++    }
++    UnlockWaylandBuffer();
++  } else {
++    MOZ_ASSERT(!mWaylandBuffer->IsLocked(),
++               "Drawing to already locked buffer?");
++    if (CommitImageSurfaceToWaylandBuffer(aInvalidRegion,
++                                          mWaylandBufferDamage)) {
++      // Our cached drawing is flushed, we can draw fullscreen again.
++      mDrawToWaylandBufferDirectly = true;
++    }
+   }
+ 
+   // We're ready to commit.
+   mPendingCommit = true;
+   CommitWaylandBuffer();
+ }
+ 
+ void WindowSurfaceWayland::FrameCallbackHandler() {
+diff --git a/widget/gtk/WindowSurfaceWayland.h b/widget/gtk/WindowSurfaceWayland.h
+--- a/widget/gtk/WindowSurfaceWayland.h
++++ b/widget/gtk/WindowSurfaceWayland.h
+@@ -5,16 +5,19 @@
+  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+ #ifndef _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_H
+ #define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_H
+ 
+ #include <prthread.h>
+ #include "mozilla/gfx/Types.h"
+ #include "nsWaylandDisplay.h"
++#ifdef HAVE_LIBDRM
++#  include "mozilla/gfx/WaylandDMABufSurface.h"
++#endif
+ 
+ #define BACK_BUFFER_NUM 2
+ 
+ namespace mozilla {
+ namespace widget {
+ 
+ // Allocates and owns shared memory for Wayland drawing surface
+ class WaylandShmPool {
+@@ -35,94 +38,192 @@ class WaylandShmPool {
+   int mShmPoolFd;
+   int mAllocatedSize;
+   void* mImageData;
+ };
+ 
+ // Holds actual graphics data for wl_surface
+ class WindowBackBuffer {
+  public:
+-  WindowBackBuffer(nsWaylandDisplay* aDisplay, int aWidth, int aHeight);
+-  ~WindowBackBuffer();
++  virtual already_AddRefed<gfx::DrawTarget> Lock() = 0;
++  virtual void Unlock(){};
++  virtual bool IsLocked() { return false; };
++
++  void Attach(wl_surface* aSurface);
++  virtual void Detach(wl_buffer* aBuffer) = 0;
++  virtual bool IsAttached() = 0;
++
++  virtual void Clear() = 0;
++  virtual bool Resize(int aWidth, int aHeight) = 0;
++
++  virtual int GetWidth() = 0;
++  virtual int GetHeight() = 0;
++  virtual wl_buffer* GetWlBuffer() = 0;
++  virtual void SetAttached() = 0;
++
++  virtual bool SetImageDataFromBuffer(
++      class WindowBackBuffer* aSourceBuffer) = 0;
++
++  bool IsMatchingSize(int aWidth, int aHeight) {
++    return aWidth == GetWidth() && aHeight == GetHeight();
++  }
++  bool IsMatchingSize(class WindowBackBuffer* aBuffer) {
++    return aBuffer->IsMatchingSize(GetWidth(), GetHeight());
++  }
++
++  static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
++
++  nsWaylandDisplay* GetWaylandDisplay() { return mWaylandDisplay; };
++
++  WindowBackBuffer(nsWaylandDisplay* aWaylandDisplay)
++      : mWaylandDisplay(aWaylandDisplay){};
++  virtual ~WindowBackBuffer(){};
++
++ private:
++  static gfx::SurfaceFormat mFormat;
++  nsWaylandDisplay* mWaylandDisplay;
++};
++
++class WindowBackBufferShm : public WindowBackBuffer {
++ public:
++  WindowBackBufferShm(nsWaylandDisplay* aWaylandDisplay, int aWidth,
++                      int aHeight);
++  ~WindowBackBufferShm();
+ 
+   already_AddRefed<gfx::DrawTarget> Lock();
+ 
+-  void Attach(wl_surface* aSurface);
+   void Detach(wl_buffer* aBuffer);
+   bool IsAttached() { return mAttached; }
+ 
+   void Clear();
+   bool Resize(int aWidth, int aHeight);
+   bool SetImageDataFromBuffer(class WindowBackBuffer* aSourceBuffer);
+ 
+-  bool IsMatchingSize(int aWidth, int aHeight) {
+-    return aWidth == mWidth && aHeight == mHeight;
+-  }
+-  bool IsMatchingSize(class WindowBackBuffer* aBuffer) {
+-    return aBuffer->mWidth == mWidth && aBuffer->mHeight == mHeight;
+-  }
++  int GetWidth() { return mWidth; };
++  int GetHeight() { return mHeight; };
+ 
+-  static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
++  wl_buffer* GetWlBuffer() { return mWaylandBuffer; };
++  void SetAttached() { mAttached = true; };
+ 
+  private:
+   void Create(int aWidth, int aHeight);
+   void Release();
+ 
+   // WaylandShmPool provides actual shared memory we draw into
+   WaylandShmPool mShmPool;
+ 
+   // wl_buffer is a wayland object that encapsulates the shared memory
+   // and passes it to wayland compositor by wl_surface object.
+   wl_buffer* mWaylandBuffer;
+   int mWidth;
+   int mHeight;
+   bool mAttached;
+-  nsWaylandDisplay* mWaylandDisplay;
+-  static gfx::SurfaceFormat mFormat;
++};
++
++#ifdef HAVE_LIBDRM
++class WindowBackBufferDMABuf : public WindowBackBuffer {
++ public:
++  WindowBackBufferDMABuf(nsWaylandDisplay* aWaylandDisplay, int aWidth,
++                         int aHeight);
++  ~WindowBackBufferDMABuf();
++
++  bool IsAttached();
++  void SetAttached();
++
++  int GetWidth();
++  int GetHeight();
++  wl_buffer* GetWlBuffer();
++
++  bool SetImageDataFromBuffer(class WindowBackBuffer* aSourceBuffer);
++
++  already_AddRefed<gfx::DrawTarget> Lock();
++  bool IsLocked();
++  void Unlock();
++
++  void Clear();
++  void Detach(wl_buffer* aBuffer);
++  bool Resize(int aWidth, int aHeight);
++
++ private:
++  WaylandDMABufSurface mDMAbufSurface;
++};
++#endif
++
++class WindowImageSurface {
++ public:
++  static void Draw(gfx::SourceSurface* aSurface, gfx::DrawTarget* aDest,
++                   const LayoutDeviceIntRegion& aRegion);
++
++  void Draw(gfx::DrawTarget* aDest,
++            LayoutDeviceIntRegion& aWaylandBufferDamage);
++
++  WindowImageSurface(gfx::SourceSurface* aSurface,
++                     const LayoutDeviceIntRegion& aUpdateRegion);
++
++ private:
++  RefPtr<gfx::SourceSurface> mSurface;
++  const LayoutDeviceIntRegion mUpdateRegion;
+ };
+ 
+ // WindowSurfaceWayland is an abstraction for wl_surface
+ // and related management
+ class WindowSurfaceWayland : public WindowSurface {
+  public:
+   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* GetWaylandBufferToDraw(int aWidth, int aHeight);
++  WindowBackBuffer* CreateWaylandBuffer(int aWidth, int aHeight);
++  WindowBackBuffer* GetWaylandBufferToDraw(int aWidth, int aHeight,
++                                           bool aFullScreenUpdate,
++                                           bool aNoBackBufferCopy);
+ 
+   already_AddRefed<gfx::DrawTarget> LockWaylandBuffer(int aWidth, int aHeight,
+-                                                      bool aClearBuffer);
++                                                      bool aClearBuffer,
++                                                      bool aFullScreenUpdate,
++                                                      bool aNoBackBufferCopy);
++  void UnlockWaylandBuffer();
++
+   already_AddRefed<gfx::DrawTarget> LockImageSurface(
+       const gfx::IntSize& aLockSize);
+-  bool CommitImageSurfaceToWaylandBuffer(const LayoutDeviceIntRegion& aRegion);
++  bool CommitImageSurfaceToWaylandBuffer(
++      const LayoutDeviceIntRegion& aRegion,
++      LayoutDeviceIntRegion& aWaylandBufferDamage);
+   void CommitWaylandBuffer();
+   void CalcRectScale(LayoutDeviceIntRect& aRect, int scale);
+ 
++  void DrawDelayedImageCommits(gfx::DrawTarget* aDrawTarget,
++                               LayoutDeviceIntRegion& aWaylandBufferDamage);
++
+   // TODO: Do we need to hold a reference to nsWindow object?
+   nsWindow* mWindow;
+   nsWaylandDisplay* mWaylandDisplay;
+   WindowBackBuffer* mWaylandBuffer;
+   LayoutDeviceIntRegion mWaylandBufferDamage;
+   WindowBackBuffer* mBackupBuffer[BACK_BUFFER_NUM];
+-  RefPtr<gfxImageSurface> mImageSurface;
+   wl_callback* mFrameCallback;
+   wl_surface* mLastCommittedSurface;
+   MessageLoop* mDisplayThreadMessageLoop;
+   WindowSurfaceWayland** mDelayedCommitHandle;
++  RefPtr<gfxImageSurface> mImageSurface;
++  AutoTArray<WindowImageSurface, 30> mDelayedImageCommits;
+   bool mDrawToWaylandBufferDirectly;
+   bool mPendingCommit;
+   bool mWaylandBufferFullScreenDamage;
+   bool mIsMainThread;
+   bool mNeedScaleFactorUpdate;
+   bool mWaitToFullScreenUpdate;
++
++  static bool UseDMABufBackend();
++  static bool mUseDMABufInitialized;
++  static bool mUseDMABuf;
+ };
+ 
+ }  // namespace widget
+ }  // namespace mozilla
+ 
+ #endif  // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_H
+diff --git a/widget/gtk/moz.build b/widget/gtk/moz.build
+--- a/widget/gtk/moz.build
++++ b/widget/gtk/moz.build
+@@ -97,17 +97,18 @@ if CONFIG['MOZ_X11']:
+ 
+ if CONFIG['MOZ_WAYLAND']:
+     UNIFIED_SOURCES += [
+         'nsClipboardWayland.cpp',
          'nsWaylandDisplay.cpp',
          'WindowSurfaceWayland.cpp',
      ]
-+    EXPORTS.mozilla.widget += [
+     EXPORTS.mozilla.widget += [
+-        'nsWaylandDisplayShutdown.h'
 +        'nsWaylandDisplay.h',
-+    ]
++        'nsWaylandDisplayShutdown.h',
+     ]
  
  if CONFIG['ACCESSIBILITY']:
      UNIFIED_SOURCES += [
-diff -up firefox-67.0/widget/gtk/mozcontainer.cpp.mozilla-1552590 firefox-67.0/widget/gtk/mozcontainer.cpp
---- firefox-67.0/widget/gtk/mozcontainer.cpp.mozilla-1552590	2019-05-27 12:15:32.026414340 +0200
-+++ firefox-67.0/widget/gtk/mozcontainer.cpp	2019-05-27 12:15:32.031414339 +0200
-@@ -567,7 +567,7 @@ struct wl_surface *moz_container_get_wl_
-                                 moz_container_get_scale(container));
- 
-     wl_surface_commit(container->surface);
--    wl_display_flush(waylandDisplay->GetDisplay());    
-+    wl_display_flush(waylandDisplay->GetDisplay());
-   }
+         'maiRedundantObjectFactory.c',
+     ]
  
-   return container->surface;
-@@ -596,9 +596,13 @@ gboolean moz_container_has_wl_egl_window
+ UNIFIED_SOURCES += [
+diff --git a/widget/gtk/mozcontainer.cpp b/widget/gtk/mozcontainer.cpp
+--- a/widget/gtk/mozcontainer.cpp
++++ b/widget/gtk/mozcontainer.cpp
+@@ -641,17 +641,19 @@ struct wl_egl_window* moz_container_get_
+   return container->eglwindow;
+ }
  
- gboolean moz_container_surface_needs_clear(MozContainer *container) {
-   gboolean state = container->surface_needs_clear;
--  container->surface_needs_clear = false;
-   return state;
+ gboolean moz_container_has_wl_egl_window(MozContainer* container) {
+   return container->eglwindow ? true : false;
  }
-+
-+void moz_container_surface_cleared(MozContainer* container) {
-+   container->surface_needs_clear = false;
+ 
+ gboolean moz_container_surface_needs_clear(MozContainer* container) {
+-  gboolean state = container->surface_needs_clear;
++  return container->surface_needs_clear;
 +}
 +
++void moz_container_surface_cleared(MozContainer* container) {
+   container->surface_needs_clear = false;
+-  return state;
+ }
  #endif
  
- void moz_container_force_default_visual(MozContainer *container) {
-diff -up firefox-67.0/widget/gtk/mozcontainer.h.mozilla-1552590 firefox-67.0/widget/gtk/mozcontainer.h
---- firefox-67.0/widget/gtk/mozcontainer.h.mozilla-1552590	2019-05-27 12:15:32.021414342 +0200
-+++ firefox-67.0/widget/gtk/mozcontainer.h	2019-05-27 12:15:32.031414339 +0200
-@@ -101,6 +101,7 @@ struct wl_egl_window *moz_container_get_
- 
- gboolean moz_container_has_wl_egl_window(MozContainer *container);
- gboolean moz_container_surface_needs_clear(MozContainer *container);
+ void moz_container_force_default_visual(MozContainer* container) {
+   container->force_default_visual = true;
+ }
+diff --git a/widget/gtk/mozcontainer.h b/widget/gtk/mozcontainer.h
+--- a/widget/gtk/mozcontainer.h
++++ b/widget/gtk/mozcontainer.h
+@@ -96,15 +96,16 @@ void moz_container_put(MozContainer* con
+ void moz_container_force_default_visual(MozContainer* container);
+ 
+ #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);
 +void moz_container_surface_cleared(MozContainer* container);
- void moz_container_scale_changed(MozContainer *container,
-                                  GtkAllocation *aAllocation);
+ void moz_container_scale_changed(MozContainer* container,
+                                  GtkAllocation* aAllocation);
  void moz_container_set_initial_draw_callback(
-diff -up firefox-67.0/widget/gtk/mozwayland/moz.build.mozilla-1552590 firefox-67.0/widget/gtk/mozwayland/moz.build
---- firefox-67.0/widget/gtk/mozwayland/moz.build.mozilla-1552590	2019-05-17 02:35:09.000000000 +0200
-+++ firefox-67.0/widget/gtk/mozwayland/moz.build	2019-05-27 12:15:32.031414339 +0200
-@@ -7,7 +7,11 @@
+     MozContainer* container, std::function<void(void)> inital_draw_cb);
+ #endif
+ 
+ #endif /* __MOZ_CONTAINER_H__ */
+diff --git a/widget/gtk/mozwayland/moz.build b/widget/gtk/mozwayland/moz.build
+--- a/widget/gtk/mozwayland/moz.build
++++ b/widget/gtk/mozwayland/moz.build
+@@ -2,12 +2,16 @@
+ # vim: set filetype=python:
+ # 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/.
+ 
  SOURCES += [
      'mozwayland.c',
  ]
@@ -471,10 +1377,15 @@ diff -up firefox-67.0/widget/gtk/mozwayland/moz.build.mozilla-1552590 firefox-67
  
  CFLAGS += CONFIG['TK_CFLAGS']
 +
-diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590 firefox-67.0/widget/gtk/nsWaylandDisplay.cpp
---- firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590	2019-05-27 12:15:32.027414340 +0200
-+++ firefox-67.0/widget/gtk/nsWaylandDisplay.cpp	2019-05-27 13:41:39.335407884 +0200
-@@ -7,10 +7,6 @@
+diff --git a/widget/gtk/nsWaylandDisplay.cpp b/widget/gtk/nsWaylandDisplay.cpp
+--- a/widget/gtk/nsWaylandDisplay.cpp
++++ b/widget/gtk/nsWaylandDisplay.cpp
+@@ -2,20 +2,16 @@
+ /* 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"
  
@@ -485,49 +1396,20 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590 firefox-67
  namespace mozilla {
  namespace widget {
  
-@@ -58,7 +54,7 @@ static nsWaylandDisplay *WaylandDisplayG
-   return nullptr;
- }
+ // nsWaylandDisplay needs to be created for each calling thread(main thread,
+ // compositor thread and render thread)
+ #define MAX_DISPLAY_CONNECTIONS 3
  
--nsWaylandDisplay *WaylandDisplayGet(GdkDisplay *aGdkDisplay) {
-+nsWaylandDisplay* WaylandDisplayGet(GdkDisplay* aGdkDisplay) {
-   if (!aGdkDisplay) {
-     aGdkDisplay = gdk_display_get_default();
-   }
-@@ -90,84 +86,193 @@ static void WaylandDisplayLoopLocked(wl_
+ static nsWaylandDisplay* gWaylandDisplays[MAX_DISPLAY_CONNECTIONS];
+@@ -107,16 +103,67 @@ void nsWaylandDisplay::SetDataDeviceMana
  
- 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::SetShm(wl_shm* aShm) { mShm = aShm; }
- 
--void nsWaylandDisplay::SetSubcompositor(wl_subcompositor *aSubcompositor) {
-+void nsWaylandDisplay::SetSubcompositor(wl_subcompositor* aSubcompositor) {
-   mSubcompositor = aSubcompositor;
- }
- 
- void nsWaylandDisplay::SetDataDeviceManager(
--    wl_data_device_manager *aDataDeviceManager) {
-+    wl_data_device_manager* aDataDeviceManager) {
-   mDataDeviceManager = aDataDeviceManager;
- }
- 
--void nsWaylandDisplay::SetSeat(wl_seat *aSeat) { mSeat = aSeat; }
-+void nsWaylandDisplay::SetSeat(wl_seat* aSeat) { mSeat = aSeat; }
+ void nsWaylandDisplay::SetSeat(wl_seat* aSeat) { mSeat = aSeat; }
  
  void nsWaylandDisplay::SetPrimarySelectionDeviceManager(
--    gtk_primary_selection_device_manager *aPrimarySelectionDeviceManager) {
-+    gtk_primary_selection_device_manager* aPrimarySelectionDeviceManager) {
+     gtk_primary_selection_device_manager* aPrimarySelectionDeviceManager) {
    mPrimarySelectionDeviceManager = aPrimarySelectionDeviceManager;
  }
  
--static void global_registry_handler(void *data, wl_registry *registry,
--                                    uint32_t id, const char *interface,
 +#ifdef HAVE_LIBDRM
 +void nsWaylandDisplay::SetDmabuf(zwp_linux_dmabuf_v1* aDmabuf) {
 +  mDmabuf = aDmabuf;
@@ -578,88 +1460,46 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590 firefox-67
 +
 +static const struct zwp_linux_dmabuf_v1_listener dmabuf_listener = {
 +    dmabuf_format, dmabuf_modifiers};
-+#endif
 +
-+static void global_registry_handler(void* data, wl_registry* registry,
-+                                    uint32_t id, const char* interface,
+ 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 (!display)
--    return;
-+  auto display = reinterpret_cast<nsWaylandDisplay*>(data);
-+  if (!display) return;
+   auto display = reinterpret_cast<nsWaylandDisplay*>(data);
+   if (!display) return;
  
    if (strcmp(interface, "wl_shm") == 0) {
--    auto shm = static_cast<wl_shm *>(
-+    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());
-+    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 *>(
-+    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,
-+    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 *>(
-+    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());
-+    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(
-+        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,
-+    wl_proxy_set_queue((struct wl_proxy*)primary_selection_device_manager,
+     auto shm = static_cast<wl_shm*>(
+@@ -144,16 +191,21 @@ static void global_registry_handler(void
                         display->GetEventQueue());
      display->SetPrimarySelectionDeviceManager(primary_selection_device_manager);
    } else if (strcmp(interface, "wl_subcompositor") == 0) {
--    auto subcompositor = static_cast<wl_subcompositor *>(
-+    auto subcompositor = static_cast<wl_subcompositor*>(
+     auto subcompositor = static_cast<wl_subcompositor*>(
          wl_registry_bind(registry, id, &wl_subcompositor_interface, 1));
--    wl_proxy_set_queue((struct wl_proxy *)subcompositor,
-+    wl_proxy_set_queue((struct wl_proxy*)subcompositor,
+     wl_proxy_set_queue((struct wl_proxy*)subcompositor,
                         display->GetEventQueue());
      display->SetSubcompositor(subcompositor);
-   }
-+#ifdef HAVE_LIBDRM
-+  else if (strcmp(interface, "zwp_linux_dmabuf_v1") == 0 && version > 2) {
++  } else if (strcmp(interface, "zwp_linux_dmabuf_v1") == 0 && version > 2) {
 +    auto dmabuf = static_cast<zwp_linux_dmabuf_v1*>(
 +        wl_registry_bind(registry, id, &zwp_linux_dmabuf_v1_interface, 3));
 +    display->SetDmabuf(dmabuf);
 +    zwp_linux_dmabuf_v1_add_listener(dmabuf, &dmabuf_listener, data);
-+  }
-+#endif
+   }
  }
  
--static void global_registry_remover(void *data, wl_registry *registry,
-+static void global_registry_remover(void* data, wl_registry* registry,
+ 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() {
-+bool nsWaylandDisplay::DispatchEventQueue() {
+@@ -162,27 +214,85 @@ bool nsWaylandDisplay::DispatchEventQueu
    wl_display_dispatch_queue_pending(mDisplay, mEventQueue);
    return true;
  }
  
--bool nsWaylandDisplay::Matches(wl_display *aDisplay) {
-+bool nsWaylandDisplay::Matches(wl_display* aDisplay) {
+ bool nsWaylandDisplay::Matches(wl_display* aDisplay) {
    return mThreadId == PR_GetCurrentThread() && aDisplay == mDisplay;
  }
  
-+#ifdef HAVE_LIBDRM
 +bool nsWaylandDisplay::ConfigureGbm() {
 +  if (!nsGbmLib::IsAvailable()) {
 +    return false;
@@ -709,9 +1549,12 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590 firefox-67
 +#endif
 +
  nsWaylandDisplay::nsWaylandDisplay(wl_display* aDisplay)
-     : mThreadId(PR_GetCurrentThread()),
+     : mDispatcherThreadLoop(nullptr),
+       mThreadId(PR_GetCurrentThread()),
        mDisplay(aDisplay),
-@@ -177,7 +282,17 @@ nsWaylandDisplay::nsWaylandDisplay(wl_di
+       mEventQueue(nullptr),
+       mDataDeviceManager(nullptr),
+       mSubcompositor(nullptr),
        mSeat(nullptr),
        mShm(nullptr),
        mPrimarySelectionDeviceManager(nullptr),
@@ -730,16 +1573,17 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590 firefox-67
    mRegistry = wl_display_get_registry(mDisplay);
    wl_registry_add_listener(mRegistry, &registry_listener, this);
  
-@@ -190,7 +305,7 @@ nsWaylandDisplay::nsWaylandDisplay(wl_di
-     mEventQueue = wl_display_create_queue(mDisplay);
-     MessageLoop::current()->PostTask(NewRunnableFunction(
-         "WaylandDisplayLoop", &WaylandDisplayLoop, mDisplay));
--    wl_proxy_set_queue((struct wl_proxy *)mRegistry, mEventQueue);
-+    wl_proxy_set_queue((struct wl_proxy*)mRegistry, mEventQueue);
-     wl_display_roundtrip_queue(mDisplay, mEventQueue);
-     wl_display_roundtrip_queue(mDisplay, mEventQueue);
-   }
-@@ -209,5 +324,79 @@ nsWaylandDisplay::~nsWaylandDisplay() {
+   if (NS_IsMainThread()) {
+     // Use default event queue in main thread operated by Gtk+.
+     mEventQueue = nullptr;
+     wl_display_roundtrip(mDisplay);
+     wl_display_roundtrip(mDisplay);
+@@ -205,10 +315,84 @@ nsWaylandDisplay::~nsWaylandDisplay() {
+   mRegistry = nullptr;
+ 
+   if (mEventQueue) {
+     wl_event_queue_destroy(mEventQueue);
+     mEventQueue = nullptr;
    }
  }
  
@@ -819,10 +1663,14 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.cpp.mozilla-1552590 firefox-67
 +
  }  // namespace widget
  }  // namespace mozilla
-diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0/widget/gtk/nsWaylandDisplay.h
---- firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590	2019-05-27 12:15:32.027414340 +0200
-+++ firefox-67.0/widget/gtk/nsWaylandDisplay.h	2019-05-27 13:38:56.012798548 +0200
-@@ -5,19 +5,38 @@
+diff --git a/widget/gtk/nsWaylandDisplay.h b/widget/gtk/nsWaylandDisplay.h
+--- a/widget/gtk/nsWaylandDisplay.h
++++ b/widget/gtk/nsWaylandDisplay.h
+@@ -1,24 +1,43 @@
+ /* -*- 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/. */
  
@@ -830,14 +1678,12 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0
 -#define __MOZ_WAYLAND_REGISTRY_H__
 +#ifndef __MOZ_WAYLAND_DISPLAY_H__
 +#define __MOZ_WAYLAND_DISPLAY_H__
- 
--#include "mozwayland/mozwayland.h"
--#include "wayland/gtk-primary-selection-client-protocol.h"
++
 +#include "mozilla/widget/mozwayland.h"
 +#include "mozilla/widget/gtk-primary-selection-client-protocol.h"
  
--namespace mozilla {
--namespace widget {
+-#include "mozwayland/mozwayland.h"
+-#include "wayland/gtk-primary-selection-client-protocol.h"
 +#include "base/message_loop.h"  // for MessageLoop
 +#include "base/task.h"          // for NewRunnableMethod, etc
 +#include "mozilla/StaticMutex.h"
@@ -849,13 +1695,9 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0
 +#  include "mozilla/widget/linux-dmabuf-unstable-v1-client-protocol.h"
 +#endif
  
- // TODO: Bug 1467125 - We need to integrate wl_display_dispatch_queue_pending()
- // with compositor event loop.
- #define EVENT_LOOP_DELAY (1000 / 240)
+ namespace mozilla {
+ namespace widget {
  
-+namespace mozilla {
-+namespace widget {
-+
 +struct GbmFormat {
 +  bool mIsSupported;
 +  bool mHasAlpha;
@@ -867,19 +1709,20 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0
  // Our general connection to Wayland display server,
  // holds our display connection and runs event loop.
  class nsWaylandDisplay {
-@@ -26,6 +45,7 @@ class nsWaylandDisplay {
+  public:
+   explicit nsWaylandDisplay(wl_display* aDisplay);
    virtual ~nsWaylandDisplay();
  
-   bool DisplayLoop();
-+  bool DispatchEventQueue();
-   bool Matches(wl_display* aDisplay);
- 
-   wl_display* GetDisplay() { return mDisplay; };
-@@ -47,7 +67,22 @@ class nsWaylandDisplay {
+   bool DispatchEventQueue();
+@@ -41,28 +60,143 @@ class nsWaylandDisplay {
+   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:
+   void Shutdown();
+ 
 +#ifdef HAVE_LIBDRM
 +  void SetDmabuf(zwp_linux_dmabuf_v1* aDmabuf);
 +  zwp_linux_dmabuf_v1* GetDmabuf() { return mDmabuf; };
@@ -891,20 +1734,21 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0
 +                         uint32_t mModifierLo);
 +#endif
 +
-+ private:
+  private:
 +#ifdef HAVE_LIBDRM
 +  bool ConfigureGbm();
 +#endif
 +
+   MessageLoop* mDispatcherThreadLoop;
    PRThread* mThreadId;
    wl_display* mDisplay;
    wl_event_queue* mEventQueue;
-@@ -56,12 +91,113 @@ private:
+   wl_data_device_manager* mDataDeviceManager;
+   wl_subcompositor* mSubcompositor;
    wl_seat* mSeat;
    wl_shm* mShm;
    gtk_primary_selection_device_manager* mPrimarySelectionDeviceManager;
--  wl_registry *mRegistry;
-+  wl_registry* mRegistry;
+   wl_registry* mRegistry;
 +#ifdef HAVE_LIBDRM
 +  zwp_linux_dmabuf_v1* mDmabuf;
 +  gbm_device* mGbmDevice;
@@ -916,7 +1760,7 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0
 +#endif
  };
  
-+void WaylandDispatchDisplays();
+ void WaylandDispatchDisplays();
  nsWaylandDisplay* WaylandDisplayGet(GdkDisplay* aGdkDisplay = nullptr);
  
 +#ifdef HAVE_LIBDRM
@@ -1015,10 +1859,35 @@ diff -up firefox-67.0/widget/gtk/nsWaylandDisplay.h.mozilla-1552590 firefox-67.0
  
 -#endif  // __MOZ_WAYLAND_REGISTRY_H__
 +#endif  // __MOZ_WAYLAND_DISPLAY_H__
-diff -up firefox-67.0/widget/gtk/nsWindow.cpp.mozilla-1552590 firefox-67.0/widget/gtk/nsWindow.cpp
---- firefox-67.0/widget/gtk/nsWindow.cpp.mozilla-1552590	2019-05-27 12:15:32.025414340 +0200
-+++ firefox-67.0/widget/gtk/nsWindow.cpp	2019-05-27 12:15:32.032414339 +0200
-@@ -6785,11 +6785,14 @@ bool nsWindow::WaylandSurfaceNeedsClear(
+diff --git a/widget/gtk/nsWindow.cpp b/widget/gtk/nsWindow.cpp
+--- a/widget/gtk/nsWindow.cpp
++++ b/widget/gtk/nsWindow.cpp
+@@ -4237,17 +4237,18 @@ LayoutDeviceIntSize nsWindow::GetSafeWin
+   // reads it as CARD16.  Sizes of pixmaps, used for drawing, are (unsigned)
+   // CARD16 in the protocol, but the server's ProcCreatePixmap returns
+   // BadAlloc if dimensions cannot be represented by signed shorts.
+   // Because we are creating Cairo surfaces to represent window buffers,
+   // we also must ensure that the window can fit in a Cairo surface.
+   LayoutDeviceIntSize result = aSize;
+   int32_t maxSize = 32767;
+   if (mLayerManager && mLayerManager->AsKnowsCompositor()) {
+-    maxSize = std::min(maxSize, mLayerManager->AsKnowsCompositor()->GetMaxTextureSize());
++    maxSize = std::min(maxSize,
++                       mLayerManager->AsKnowsCompositor()->GetMaxTextureSize());
+   }
+   if (result.width > maxSize) {
+     result.width = maxSize;
+   }
+   if (result.height > maxSize) {
+     result.height = maxSize;
+   }
+   return result;
+@@ -6827,21 +6828,24 @@ wl_surface* nsWindow::GetWaylandSurface(
+       "drawing!");
+   return nullptr;
+ }
+ 
+ bool nsWindow::WaylandSurfaceNeedsClear() {
    if (mContainer) {
      return moz_container_surface_needs_clear(MOZ_CONTAINER(mContainer));
    }
@@ -1036,10 +1905,20 @@ diff -up firefox-67.0/widget/gtk/nsWindow.cpp.mozilla-1552590 firefox-67.0/widge
  #endif
  
  #ifdef MOZ_X11
-diff -up firefox-67.0/widget/gtk/nsWindow.h.mozilla-1552590 firefox-67.0/widget/gtk/nsWindow.h
---- firefox-67.0/widget/gtk/nsWindow.h.mozilla-1552590	2019-05-27 12:15:32.025414340 +0200
-+++ firefox-67.0/widget/gtk/nsWindow.h	2019-05-27 12:15:32.033414339 +0200
-@@ -345,6 +345,7 @@ class nsWindow final : public nsBaseWidg
+ /* 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
+diff --git a/widget/gtk/nsWindow.h b/widget/gtk/nsWindow.h
+--- a/widget/gtk/nsWindow.h
++++ b/widget/gtk/nsWindow.h
+@@ -341,16 +341,17 @@ class nsWindow final : public nsBaseWidg
+ 
+ #ifdef MOZ_X11
+   Display* XDisplay() { return mXDisplay; }
+ #endif
+ #ifdef MOZ_WAYLAND
    wl_display* GetWaylandDisplay();
    wl_surface* GetWaylandSurface();
    bool WaylandSurfaceNeedsClear();
@@ -1047,9 +1926,15 @@ diff -up firefox-67.0/widget/gtk/nsWindow.h.mozilla-1552590 firefox-67.0/widget/
  #endif
    virtual void GetCompositorWidgetInitData(
        mozilla::widget::CompositorWidgetInitData* aInitData) override;
-diff -up firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h.mozilla-1552590 firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h
---- firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h.mozilla-1552590	2019-05-27 12:15:32.033414339 +0200
-+++ firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h	2019-05-27 12:15:32.033414339 +0200
+ 
+   virtual nsresult SetNonClientMargins(
+       LayoutDeviceIntMargin& aMargins) override;
+   void SetDrawsInTitlebar(bool aState) override;
+   virtual void UpdateWindowDraggingRegion(
+diff --git a/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h b/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h
 @@ -0,0 +1,650 @@
 +/* Generated by wayland-scanner 1.17.0 */
 +
@@ -1701,9 +2586,10 @@ diff -up firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protoco
 +#endif
 +
 +#endif
-diff -up firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c.mozilla-1552590 firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c
---- firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c.mozilla-1552590	2019-05-27 12:15:32.033414339 +0200
-+++ firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c	2019-05-27 12:15:32.033414339 +0200
+diff --git a/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c b/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c
+new file mode 100644
+--- /dev/null
++++ b/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c
 @@ -0,0 +1,81 @@
 +/* Generated by wayland-scanner 1.17.0 */
 +
@@ -1786,10 +2672,15 @@ diff -up firefox-67.0/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c.moz
 +    "zwp_linux_buffer_params_v1",        3, 4,
 +    zwp_linux_buffer_params_v1_requests, 2, zwp_linux_buffer_params_v1_events,
 +};
-diff -up firefox-67.0/widget/gtk/wayland/moz.build.mozilla-1552590 firefox-67.0/widget/gtk/wayland/moz.build
---- firefox-67.0/widget/gtk/wayland/moz.build.mozilla-1552590	2019-05-17 02:35:08.000000000 +0200
-+++ firefox-67.0/widget/gtk/wayland/moz.build	2019-05-27 12:15:32.033414339 +0200
-@@ -9,6 +9,12 @@ with Files("**"):
+diff --git a/widget/gtk/wayland/moz.build b/widget/gtk/wayland/moz.build
+--- a/widget/gtk/wayland/moz.build
++++ b/widget/gtk/wayland/moz.build
+@@ -4,16 +4,22 @@
+ # 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/.
+ 
+ with Files("**"):
+     BUG_COMPONENT = ("Core", "Widget: Gtk")
  
  SOURCES += [
      'gtk-primary-selection-protocol.c',
@@ -1802,706 +2693,9 @@ diff -up firefox-67.0/widget/gtk/wayland/moz.build.mozilla-1552590 firefox-67.0/
  ]
  
  include('/ipc/chromium/chromium-config.mozbuild')
-diff -up firefox-67.0/widget/gtk/WindowSurfaceWayland.cpp.mozilla-1552590 firefox-67.0/widget/gtk/WindowSurfaceWayland.cpp
---- firefox-67.0/widget/gtk/WindowSurfaceWayland.cpp.mozilla-1552590	2019-05-27 12:15:32.028414340 +0200
-+++ firefox-67.0/widget/gtk/WindowSurfaceWayland.cpp	2019-05-27 12:15:32.033414339 +0200
-@@ -35,6 +35,9 @@ extern mozilla::LazyLogModule gWidgetWay
- namespace mozilla {
- namespace widget {
- 
-+bool WindowSurfaceWayland::mUseDMABuf = false;
-+bool WindowSurfaceWayland::mUseDMABufInitialized = false;
-+
- /*
-   Wayland multi-thread rendering scheme
- 
-@@ -258,7 +261,7 @@ static void buffer_release(void* data, w
- 
- static const struct wl_buffer_listener buffer_listener = {buffer_release};
- 
--void WindowBackBuffer::Create(int aWidth, int aHeight) {
-+void WindowBackBufferShm::Create(int aWidth, int aHeight) {
-   MOZ_ASSERT(!IsAttached(), "We can't resize attached buffers.");
- 
-   int newBufferSize = aWidth * aHeight * BUFFER_BPP;
-@@ -268,7 +271,7 @@ void WindowBackBuffer::Create(int aWidth
-       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,
--                     mWaylandDisplay->GetEventQueue());
-+                     GetWaylandDisplay()->GetEventQueue());
-   wl_buffer_add_listener(mWaylandBuffer, &buffer_listener, this);
- 
-   mWidth = aWidth;
-@@ -280,31 +283,31 @@ void WindowBackBuffer::Create(int aWidth
-       mWaylandBuffer ? wl_proxy_get_id((struct wl_proxy*)mWaylandBuffer) : -1));
- }
- 
--void WindowBackBuffer::Release() {
-+void WindowBackBufferShm::Release() {
-   LOGWAYLAND(("%s [%p]\n", __PRETTY_FUNCTION__, (void*)this));
- 
-   wl_buffer_destroy(mWaylandBuffer);
-   mWidth = mHeight = 0;
- }
- 
--void WindowBackBuffer::Clear() {
-+void WindowBackBufferShm::Clear() {
-   memset(mShmPool.GetImageData(), 0, mHeight * mWidth * BUFFER_BPP);
- }
- 
--WindowBackBuffer::WindowBackBuffer(nsWaylandDisplay* aWaylandDisplay,
--                                   int aWidth, int aHeight)
--    : mShmPool(aWaylandDisplay, aWidth * aHeight * BUFFER_BPP),
-+WindowBackBufferShm::WindowBackBufferShm(nsWaylandDisplay* aWaylandDisplay,
-+                                         int aWidth, int aHeight)
-+    : WindowBackBuffer(aWaylandDisplay),
-+      mShmPool(aWaylandDisplay, aWidth * aHeight * BUFFER_BPP),
-       mWaylandBuffer(nullptr),
-       mWidth(aWidth),
-       mHeight(aHeight),
--      mAttached(false),
--      mWaylandDisplay(aWaylandDisplay) {
-+      mAttached(false) {
-   Create(aWidth, aHeight);
- }
- 
--WindowBackBuffer::~WindowBackBuffer() { Release(); }
-+WindowBackBufferShm::~WindowBackBufferShm() { Release(); }
- 
--bool WindowBackBuffer::Resize(int aWidth, int aHeight) {
-+bool WindowBackBufferShm::Resize(int aWidth, int aHeight) {
-   if (aWidth == mWidth && aHeight == mHeight) return true;
- 
-   LOGWAYLAND(
-@@ -317,20 +320,20 @@ bool WindowBackBuffer::Resize(int aWidth
- }
- 
- void WindowBackBuffer::Attach(wl_surface* aSurface) {
--  LOGWAYLAND((
--      "%s [%p] wl_surface %p ID %d wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
--      (void*)this, (void*)aSurface,
--      aSurface ? wl_proxy_get_id((struct wl_proxy*)aSurface) : -1,
--      (void*)mWaylandBuffer,
--      mWaylandBuffer ? wl_proxy_get_id((struct wl_proxy*)mWaylandBuffer) : -1));
-+  LOGWAYLAND(
-+      ("%s [%p] wl_surface %p ID %d wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
-+       (void*)this, (void*)aSurface,
-+       aSurface ? wl_proxy_get_id((struct wl_proxy*)aSurface) : -1,
-+       (void*)GetWlBuffer(),
-+       GetWlBuffer() ? wl_proxy_get_id((struct wl_proxy*)GetWlBuffer()) : -1));
- 
--  wl_surface_attach(aSurface, mWaylandBuffer, 0, 0);
-+  wl_surface_attach(aSurface, GetWlBuffer(), 0, 0);
-   wl_surface_commit(aSurface);
--  wl_display_flush(mWaylandDisplay->GetDisplay());
--  mAttached = true;
-+  wl_display_flush(GetWaylandDisplay()->GetDisplay());
-+  SetAttached();
- }
- 
--void WindowBackBuffer::Detach(wl_buffer* aBuffer) {
-+void WindowBackBufferShm::Detach(wl_buffer* aBuffer) {
-   LOGWAYLAND(("%s [%p] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__, (void*)this,
-               (void*)aBuffer,
-               aBuffer ? wl_proxy_get_id((struct wl_proxy*)aBuffer) : -1));
-@@ -338,19 +341,20 @@ void WindowBackBuffer::Detach(wl_buffer*
-   mAttached = false;
- }
- 
--bool WindowBackBuffer::SetImageDataFromBuffer(
-+bool WindowBackBufferShm::SetImageDataFromBuffer(
-     class WindowBackBuffer* aSourceBuffer) {
--  if (!IsMatchingSize(aSourceBuffer)) {
--    Resize(aSourceBuffer->mWidth, aSourceBuffer->mHeight);
-+  auto sourceBuffer = static_cast<class WindowBackBufferShm*>(aSourceBuffer);
-+  if (!IsMatchingSize(sourceBuffer)) {
-+    Resize(sourceBuffer->mWidth, sourceBuffer->mHeight);
-   }
- 
-   mShmPool.SetImageDataFromPool(
--      &aSourceBuffer->mShmPool,
--      aSourceBuffer->mWidth * aSourceBuffer->mHeight * BUFFER_BPP);
-+      &sourceBuffer->mShmPool,
-+      sourceBuffer->mWidth * sourceBuffer->mHeight * BUFFER_BPP);
-   return true;
- }
- 
--already_AddRefed<gfx::DrawTarget> WindowBackBuffer::Lock() {
-+already_AddRefed<gfx::DrawTarget> WindowBackBufferShm::Lock() {
-   LOGWAYLAND((
-       "%s [%p] [%d x %d] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
-       (void*)this, mWidth, mHeight, (void*)mWaylandBuffer,
-@@ -359,9 +363,71 @@ already_AddRefed<gfx::DrawTarget> Window
-   gfx::IntSize lockSize(mWidth, mHeight);
-   return gfxPlatform::CreateDrawTargetForData(
-       static_cast<unsigned char*>(mShmPool.GetImageData()), lockSize,
--      BUFFER_BPP * mWidth, mFormat);
-+      BUFFER_BPP * mWidth, GetSurfaceFormat());
-+}
-+
-+#ifdef HAVE_LIBDRM
-+WindowBackBufferDMABuf::WindowBackBufferDMABuf(
-+    nsWaylandDisplay* aWaylandDisplay, int aWidth, int aHeight)
-+    : WindowBackBuffer(aWaylandDisplay) {
-+  mDMAbufSurface.Create(aWidth, aHeight);
- }
- 
-+WindowBackBufferDMABuf::~WindowBackBufferDMABuf() { mDMAbufSurface.Release(); }
-+
-+already_AddRefed<gfx::DrawTarget> WindowBackBufferDMABuf::Lock() {
-+  LOGWAYLAND(
-+      ("%s [%p] [%d x %d] wl_buffer %p ID %d\n", __PRETTY_FUNCTION__,
-+       (void*)this, GetWidth(), GetHeight(), (void*)GetWlBuffer(),
-+       GetWlBuffer() ? wl_proxy_get_id((struct wl_proxy*)GetWlBuffer()) : -1));
-+
-+  uint32_t stride;
-+  void* pixels = mDMAbufSurface.Map(&stride);
-+  gfx::IntSize lockSize(GetWidth(), GetHeight());
-+  return gfxPlatform::CreateDrawTargetForData(
-+      static_cast<unsigned char*>(pixels), lockSize, stride,
-+      GetSurfaceFormat());
-+}
-+
-+void WindowBackBufferDMABuf::Unlock() { mDMAbufSurface.Unmap(); }
-+
-+bool WindowBackBufferDMABuf::IsAttached() {
-+  return mDMAbufSurface.WLBufferIsAttached();
-+}
-+
-+void WindowBackBufferDMABuf::SetAttached() {
-+  return mDMAbufSurface.WLBufferSetAttached();
-+}
-+
-+int WindowBackBufferDMABuf::GetWidth() { return mDMAbufSurface.GetWidth(); }
-+
-+int WindowBackBufferDMABuf::GetHeight() { return mDMAbufSurface.GetHeight(); }
-+
-+wl_buffer* WindowBackBufferDMABuf::GetWlBuffer() {
-+  return mDMAbufSurface.GetWLBuffer();
-+}
-+
-+bool WindowBackBufferDMABuf::IsLocked() { return mDMAbufSurface.IsMapped(); }
-+
-+bool WindowBackBufferDMABuf::Resize(int aWidth, int aHeight) {
-+  return mDMAbufSurface.Resize(aWidth, aHeight);
-+}
-+
-+bool WindowBackBufferDMABuf::SetImageDataFromBuffer(
-+    class WindowBackBuffer* aSourceBuffer) {
-+  WindowBackBufferDMABuf* source =
-+      static_cast<WindowBackBufferDMABuf*>(aSourceBuffer);
-+  mDMAbufSurface.CopyFrom(&source->mDMAbufSurface);
-+  return true;
-+}
-+
-+void WindowBackBufferDMABuf::Detach(wl_buffer* aBuffer) {
-+  mDMAbufSurface.WLBufferDetach();
-+}
-+
-+void WindowBackBufferDMABuf::Clear() { mDMAbufSurface.Clear(); }
-+#endif
-+
- static void frame_callback_handler(void* data, struct wl_callback* callback,
-                                    uint32_t time) {
-   auto surface = reinterpret_cast<WindowSurfaceWayland*>(data);
-@@ -415,13 +481,50 @@ WindowSurfaceWayland::~WindowSurfaceWayl
-   }
- }
- 
--WindowBackBuffer* WindowSurfaceWayland::GetWaylandBufferToDraw(int aWidth,
--                                                               int aHeight) {
-+bool WindowSurfaceWayland::UseDMABufBackend() {
-+  if (!mUseDMABufInitialized) {
-+#ifdef HAVE_LIBDRM
-+    if (WaylandDMABufSurface::IsAvailable()) {
-+      mUseDMABuf =
-+          Preferences::GetBool("gfx.wayland_dmabuf_backend.enabled", false);
-+    }
-+#endif
-+    mUseDMABufInitialized = true;
-+  }
-+  return mUseDMABuf;
-+}
-+
-+WindowBackBuffer* WindowSurfaceWayland::CreateWaylandBuffer(int aWidth,
-+                                                            int aHeight) {
-+  if (UseDMABufBackend()) {
-+    static bool sDMABufBufferCreated = false;
-+    WindowBackBuffer* buffer =
-+        new WindowBackBufferDMABuf(mWaylandDisplay, aWidth, aHeight);
-+    if (buffer) {
-+      sDMABufBufferCreated = true;
-+      return buffer;
-+    }
-+    // If this is the first failure and there's no dmabuf already active
-+    // we can safely fallback to Shm. Otherwise we can't mix DMAbuf and
-+    // SHM buffers so just fails now.
-+    if (sDMABufBufferCreated) {
-+      NS_WARNING("Failed to allocate DMABuf buffer!");
-+      return nullptr;
-+    } else {
-+      NS_WARNING("Wayland DMABuf failed, switched back to Shm backend!");
-+      mUseDMABuf = false;
-+    }
-+  }
-+  return new WindowBackBufferShm(mWaylandDisplay, aWidth, aHeight);
-+}
-+
-+WindowBackBuffer* WindowSurfaceWayland::GetWaylandBufferToDraw(
-+    int aWidth, int aHeight, bool aFullScreenUpdate, bool aNoBackBufferCopy) {
-   if (!mWaylandBuffer) {
-     LOGWAYLAND(("%s [%p] Create [%d x %d]\n", __PRETTY_FUNCTION__, (void*)this,
-                 aWidth, aHeight));
- 
--    mWaylandBuffer = new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
-+    mWaylandBuffer = CreateWaylandBuffer(aWidth, aHeight);
-     mWaitToFullScreenUpdate = true;
-     return mWaylandBuffer;
-   }
-@@ -447,8 +550,7 @@ WindowBackBuffer* WindowSurfaceWayland::
-   for (availableBuffer = 0; availableBuffer < BACK_BUFFER_NUM;
-        availableBuffer++) {
-     if (!mBackupBuffer[availableBuffer]) {
--      mBackupBuffer[availableBuffer] =
--          new WindowBackBuffer(mWaylandDisplay, aWidth, aHeight);
-+      mBackupBuffer[availableBuffer] = CreateWaylandBuffer(aWidth, aHeight);
-       break;
-     }
- 
-@@ -464,17 +566,26 @@ WindowBackBuffer* WindowSurfaceWayland::
-     return nullptr;
-   }
- 
-+  bool bufferFlip = mWaylandBuffer->IsMatchingSize(aWidth, aHeight);
-+  if (bufferFlip && aNoBackBufferCopy && !aFullScreenUpdate) {
-+    LOGWAYLAND(("%s [%p] Delayed hard copy from old buffer [%d x %d]\n",
-+                __PRETTY_FUNCTION__, (void*)this, aWidth, aHeight));
-+    return nullptr;
-+  }
-+
-   WindowBackBuffer* lastWaylandBuffer = mWaylandBuffer;
-   mWaylandBuffer = mBackupBuffer[availableBuffer];
-   mBackupBuffer[availableBuffer] = lastWaylandBuffer;
- 
--  if (lastWaylandBuffer->IsMatchingSize(aWidth, aHeight)) {
--    LOGWAYLAND(("%s [%p] Copy from old buffer [%d x %d]\n", __PRETTY_FUNCTION__,
--                (void*)this, aWidth, aHeight));
-+  if (bufferFlip) {
-     // 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.
--    mWaylandBuffer->SetImageDataFromBuffer(lastWaylandBuffer);
-+    // existing data to the new buffer if we don't do fullscreen redraw.
-+    if (!aFullScreenUpdate) {
-+      LOGWAYLAND(("%s [%p] Copy from old buffer [%d x %d]\n",
-+                  __PRETTY_FUNCTION__, (void*)this, aWidth, aHeight));
-+      mWaylandBuffer->SetImageDataFromBuffer(lastWaylandBuffer);
-+    }
-     // When buffer switches we need to damage whole screen
-     // (https://bugzilla.redhat.com/show_bug.cgi?id=1418260)
-     mWaylandBufferFullScreenDamage = true;
-@@ -491,11 +602,15 @@ WindowBackBuffer* WindowSurfaceWayland::
- }
- 
- already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockWaylandBuffer(
--    int aWidth, int aHeight, bool aClearBuffer) {
--  WindowBackBuffer* buffer = GetWaylandBufferToDraw(aWidth, aHeight);
-+    int aWidth, int aHeight, bool aClearBuffer, bool aFullScreenUpdate,
-+    bool aNoBackBufferCopy) {
-+  WindowBackBuffer* buffer = GetWaylandBufferToDraw(
-+      aWidth, aHeight, aFullScreenUpdate, aNoBackBufferCopy);
-   if (!buffer) {
--    NS_WARNING(
--        "WindowSurfaceWayland::LockWaylandBuffer(): No buffer available");
-+    if (!aNoBackBufferCopy) {
-+      NS_WARNING(
-+          "WindowSurfaceWayland::LockWaylandBuffer(): No buffer available");
-+    }
-     return nullptr;
-   }
- 
-@@ -506,6 +621,8 @@ already_AddRefed<gfx::DrawTarget> Window
-   return buffer->Lock();
- }
- 
-+void WindowSurfaceWayland::UnlockWaylandBuffer() { mWaylandBuffer->Unlock(); }
-+
- already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockImageSurface(
-     const gfx::IntSize& aLockSize) {
-   if (!mImageSurface || mImageSurface->CairoStatus() ||
-@@ -555,10 +672,18 @@ already_AddRefed<gfx::DrawTarget> Window
-        lockSize.height == screenRect.height);
- 
-   if (mDrawToWaylandBufferDirectly) {
--    RefPtr<gfx::DrawTarget> dt =
--        LockWaylandBuffer(screenRect.width, screenRect.height,
--                          mWindow->WaylandSurfaceNeedsClear());
-+    // If there's any pending image commit scratch them as we're going
-+    // to redraw the whole sceen anyway.
-+    mDelayedImageCommits.Clear();
-+
-+    bool needsClear = mWindow->WaylandSurfaceNeedsClear();
-+    RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(
-+        screenRect.width, screenRect.height, needsClear,
-+        /* aFullScreenUpdate */ true, /* aNoBackBufferCopy */ true);
-     if (dt) {
-+      if (needsClear) {
-+        mWindow->WaylandSurfaceCleared();
-+      }
-       // When we have a request to update whole screen at once
-       // (surface was created, resized or changed somehow)
-       // we also need update scale factor of the screen.
-@@ -577,8 +702,49 @@ already_AddRefed<gfx::DrawTarget> Window
-   return LockImageSurface(lockSize);
- }
- 
-+void WindowImageSurface::Draw(gfx::SourceSurface* aSurface,
-+                              gfx::DrawTarget* aDest,
-+                              const LayoutDeviceIntRegion& aRegion) {
-+  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());
-+    }
-+    aDest->PushDeviceSpaceClipRects(rects.Elements(), rects.Length());
-+  }
-+
-+  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
-+  gfx::Rect rect(bounds);
-+  aDest->DrawSurface(aSurface, rect, rect);
-+
-+  if (numRects != 1) {
-+    aDest->PopClip();
-+  }
-+}
-+
-+void WindowImageSurface::Draw(gfx::DrawTarget* aDest,
-+                              LayoutDeviceIntRegion& aWaylandBufferDamage) {
-+  Draw(mSurface.get(), aDest, mUpdateRegion);
-+  aWaylandBufferDamage.OrWith(mUpdateRegion);
-+}
-+
-+WindowImageSurface::WindowImageSurface(
-+    gfx::SourceSurface* aSurface, const LayoutDeviceIntRegion& aUpdateRegion)
-+    : mSurface(aSurface), mUpdateRegion(aUpdateRegion){};
-+
-+void WindowSurfaceWayland::DrawDelayedImageCommits(
-+    gfx::DrawTarget* aDrawTarget, LayoutDeviceIntRegion& aWaylandBufferDamage) {
-+  for (unsigned int i = 0; i < mDelayedImageCommits.Length(); i++) {
-+    mDelayedImageCommits[i].Draw(aDrawTarget, aWaylandBufferDamage);
-+  }
-+  mDelayedImageCommits.Clear();
-+}
-+
- bool WindowSurfaceWayland::CommitImageSurfaceToWaylandBuffer(
--    const LayoutDeviceIntRegion& aRegion) {
-+    const LayoutDeviceIntRegion& aRegion,
-+    LayoutDeviceIntRegion& aWaylandBufferDamage) {
-   MOZ_ASSERT(!mDrawToWaylandBufferDirectly);
- 
-   LayoutDeviceIntRect screenRect = mWindow->GetBounds();
-@@ -589,30 +755,31 @@ bool WindowSurfaceWayland::CommitImageSu
-     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) {
-+  if (!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();
-+  bool needsClear = mWindow->WaylandSurfaceNeedsClear();
-+  RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(
-+      screenRect.width, screenRect.height, needsClear,
-+      /* fullscreenDrawing */ false, /* aNoBackBufferCopy */ true);
-+  if (dt) {
-+    if (needsClear) {
-+      mWindow->WaylandSurfaceCleared();
-+    }
-+    // Draw any delayed image commits first
-+    DrawDelayedImageCommits(dt, aWaylandBufferDamage);
-+    WindowImageSurface::Draw(surf, dt, aRegion);
-+    // Submit all drawing to final Wayland buffer upload
-+    aWaylandBufferDamage.OrWith(aRegion);
-+    UnlockWaylandBuffer();
-+  } else {
-+    mDelayedImageCommits.AppendElement(WindowImageSurface(surf, aRegion));
-+    return false;
-   }
- 
-   return true;
-@@ -653,6 +820,24 @@ void WindowSurfaceWayland::CommitWayland
-     return;
-   }
- 
-+  if (!mDrawToWaylandBufferDirectly) {
-+    // There's some cached drawings - try to flush them now.
-+    LayoutDeviceIntRect screenRect = mWindow->GetBounds();
-+    bool needsClear = mWindow->WaylandSurfaceNeedsClear();
-+    RefPtr<gfx::DrawTarget> dt =
-+        LockWaylandBuffer(screenRect.width, screenRect.height, needsClear,
-+                          /* fullscreenInvalidate */ false,
-+                          /* aNoBackBufferCopy */ true);
-+    if (dt) {
-+      if (needsClear) {
-+        mWindow->WaylandSurfaceCleared();
-+      }
-+      DrawDelayedImageCommits(dt, mWaylandBufferDamage);
-+      UnlockWaylandBuffer();
-+      mDrawToWaylandBufferDirectly = true;
-+    }
-+  }
-+
-   wl_surface* waylandSurface = mWindow->GetWaylandSurface();
-   if (!waylandSurface) {
-     // Target window is not created yet - delay the commit. This can happen only
-@@ -745,14 +930,21 @@ void WindowSurfaceWayland::Commit(const
-   }
- #endif
- 
--  // 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);
-+  if (mDrawToWaylandBufferDirectly) {
-+    MOZ_ASSERT(mWaylandBuffer->IsLocked());
-+    // If we're not at fullscreen damage add drawing area from aInvalidRegion
-+    if (!mWaylandBufferFullScreenDamage) {
-+      mWaylandBufferDamage.OrWith(aInvalidRegion);
-+    }
-+    UnlockWaylandBuffer();
-+  } else {
-+    MOZ_ASSERT(!mWaylandBuffer->IsLocked(),
-+               "Drawing to already locked buffer?");
-+    if (CommitImageSurfaceToWaylandBuffer(aInvalidRegion,
-+                                          mWaylandBufferDamage)) {
-+      // Our cached drawing is flushed, we can draw fullscreen again.
-+      mDrawToWaylandBufferDirectly = true;
-+    }
-   }
- 
-   // We're ready to commit.
-diff -up firefox-67.0/widget/gtk/WindowSurfaceWayland.h.mozilla-1552590 firefox-67.0/widget/gtk/WindowSurfaceWayland.h
---- firefox-67.0/widget/gtk/WindowSurfaceWayland.h.mozilla-1552590	2019-05-27 12:15:32.028414340 +0200
-+++ firefox-67.0/widget/gtk/WindowSurfaceWayland.h	2019-05-27 12:15:32.034414339 +0200
-@@ -10,6 +10,9 @@
- #include <prthread.h>
- #include "mozilla/gfx/Types.h"
- #include "nsWaylandDisplay.h"
-+#ifdef HAVE_LIBDRM
-+#  include "mozilla/gfx/WaylandDMABufSurface.h"
-+#endif
- 
- #define BACK_BUFFER_NUM 2
- 
-@@ -40,12 +43,53 @@ class WaylandShmPool {
- // Holds actual graphics data for wl_surface
- class WindowBackBuffer {
-  public:
--  WindowBackBuffer(nsWaylandDisplay* aDisplay, int aWidth, int aHeight);
--  ~WindowBackBuffer();
-+  virtual already_AddRefed<gfx::DrawTarget> Lock() = 0;
-+  virtual void Unlock(){};
-+  virtual bool IsLocked() { return false; };
-+
-+  void Attach(wl_surface* aSurface);
-+  virtual void Detach(wl_buffer* aBuffer) = 0;
-+  virtual bool IsAttached() = 0;
-+
-+  virtual void Clear() = 0;
-+  virtual bool Resize(int aWidth, int aHeight) = 0;
-+
-+  virtual int GetWidth() = 0;
-+  virtual int GetHeight() = 0;
-+  virtual wl_buffer* GetWlBuffer() = 0;
-+  virtual void SetAttached() = 0;
-+
-+  virtual bool SetImageDataFromBuffer(
-+      class WindowBackBuffer* aSourceBuffer) = 0;
-+
-+  bool IsMatchingSize(int aWidth, int aHeight) {
-+    return aWidth == GetWidth() && aHeight == GetHeight();
-+  }
-+  bool IsMatchingSize(class WindowBackBuffer* aBuffer) {
-+    return aBuffer->IsMatchingSize(GetWidth(), GetHeight());
-+  }
-+
-+  static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
-+
-+  nsWaylandDisplay* GetWaylandDisplay() { return mWaylandDisplay; };
-+
-+  WindowBackBuffer(nsWaylandDisplay* aWaylandDisplay)
-+      : mWaylandDisplay(aWaylandDisplay){};
-+  virtual ~WindowBackBuffer(){};
-+
-+ private:
-+  static gfx::SurfaceFormat mFormat;
-+  nsWaylandDisplay* mWaylandDisplay;
-+};
-+
-+class WindowBackBufferShm : public WindowBackBuffer {
-+ public:
-+  WindowBackBufferShm(nsWaylandDisplay* aWaylandDisplay, int aWidth,
-+                      int aHeight);
-+  ~WindowBackBufferShm();
- 
-   already_AddRefed<gfx::DrawTarget> Lock();
- 
--  void Attach(wl_surface* aSurface);
-   void Detach(wl_buffer* aBuffer);
-   bool IsAttached() { return mAttached; }
- 
-@@ -53,14 +97,11 @@ class WindowBackBuffer {
-   bool Resize(int aWidth, int aHeight);
-   bool SetImageDataFromBuffer(class WindowBackBuffer* aSourceBuffer);
- 
--  bool IsMatchingSize(int aWidth, int aHeight) {
--    return aWidth == mWidth && aHeight == mHeight;
--  }
--  bool IsMatchingSize(class WindowBackBuffer* aBuffer) {
--    return aBuffer->mWidth == mWidth && aBuffer->mHeight == mHeight;
--  }
-+  int GetWidth() { return mWidth; };
-+  int GetHeight() { return mHeight; };
- 
--  static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
-+  wl_buffer* GetWlBuffer() { return mWaylandBuffer; };
-+  void SetAttached() { mAttached = true; };
- 
-  private:
-   void Create(int aWidth, int aHeight);
-@@ -75,8 +116,51 @@ class WindowBackBuffer {
-   int mWidth;
-   int mHeight;
-   bool mAttached;
--  nsWaylandDisplay* mWaylandDisplay;
--  static gfx::SurfaceFormat mFormat;
-+};
-+
-+#ifdef HAVE_LIBDRM
-+class WindowBackBufferDMABuf : public WindowBackBuffer {
-+ public:
-+  WindowBackBufferDMABuf(nsWaylandDisplay* aWaylandDisplay, int aWidth,
-+                         int aHeight);
-+  ~WindowBackBufferDMABuf();
-+
-+  bool IsAttached();
-+  void SetAttached();
-+
-+  int GetWidth();
-+  int GetHeight();
-+  wl_buffer* GetWlBuffer();
-+
-+  bool SetImageDataFromBuffer(class WindowBackBuffer* aSourceBuffer);
-+
-+  already_AddRefed<gfx::DrawTarget> Lock();
-+  bool IsLocked();
-+  void Unlock();
-+
-+  void Clear();
-+  void Detach(wl_buffer* aBuffer);
-+  bool Resize(int aWidth, int aHeight);
-+
-+ private:
-+  WaylandDMABufSurface mDMAbufSurface;
-+};
-+#endif
-+
-+class WindowImageSurface {
-+ public:
-+  static void Draw(gfx::SourceSurface* aSurface, gfx::DrawTarget* aDest,
-+                   const LayoutDeviceIntRegion& aRegion);
-+
-+  void Draw(gfx::DrawTarget* aDest,
-+            LayoutDeviceIntRegion& aWaylandBufferDamage);
-+
-+  WindowImageSurface(gfx::SourceSurface* aSurface,
-+                     const LayoutDeviceIntRegion& aUpdateRegion);
-+
-+ private:
-+  RefPtr<gfx::SourceSurface> mSurface;
-+  const LayoutDeviceIntRegion mUpdateRegion;
- };
- 
- // WindowSurfaceWayland is an abstraction for wl_surface
-@@ -93,33 +177,50 @@ class WindowSurfaceWayland : public Wind
-   void DelayedCommitHandler();
- 
-  private:
--  WindowBackBuffer* GetWaylandBufferToDraw(int aWidth, int aHeight);
-+  WindowBackBuffer* CreateWaylandBuffer(int aWidth, int aHeight);
-+  WindowBackBuffer* GetWaylandBufferToDraw(int aWidth, int aHeight,
-+                                           bool aFullScreenUpdate,
-+                                           bool aNoBackBufferCopy);
  
-   already_AddRefed<gfx::DrawTarget> LockWaylandBuffer(int aWidth, int aHeight,
--                                                      bool aClearBuffer);
-+                                                      bool aClearBuffer,
-+                                                      bool aFullScreenUpdate,
-+                                                      bool aNoBackBufferCopy);
-+  void UnlockWaylandBuffer();
-+
-   already_AddRefed<gfx::DrawTarget> LockImageSurface(
-       const gfx::IntSize& aLockSize);
--  bool CommitImageSurfaceToWaylandBuffer(const LayoutDeviceIntRegion& aRegion);
-+  bool CommitImageSurfaceToWaylandBuffer(
-+      const LayoutDeviceIntRegion& aRegion,
-+      LayoutDeviceIntRegion& aWaylandBufferDamage);
-   void CommitWaylandBuffer();
-   void CalcRectScale(LayoutDeviceIntRect& aRect, int scale);
+ FINAL_LIBRARY = 'xul'
  
-+  void DrawDelayedImageCommits(gfx::DrawTarget* aDrawTarget,
-+                               LayoutDeviceIntRegion& aWaylandBufferDamage);
-+
-   // TODO: Do we need to hold a reference to nsWindow object?
-   nsWindow* mWindow;
-   nsWaylandDisplay* mWaylandDisplay;
-   WindowBackBuffer* mWaylandBuffer;
-   LayoutDeviceIntRegion mWaylandBufferDamage;
-   WindowBackBuffer* mBackupBuffer[BACK_BUFFER_NUM];
--  RefPtr<gfxImageSurface> mImageSurface;
-   wl_callback* mFrameCallback;
-   wl_surface* mLastCommittedSurface;
-   MessageLoop* mDisplayThreadMessageLoop;
-   WindowSurfaceWayland** mDelayedCommitHandle;
-+  RefPtr<gfxImageSurface> mImageSurface;
-+  AutoTArray<WindowImageSurface, 30> mDelayedImageCommits;
-   bool mDrawToWaylandBufferDirectly;
-   bool mPendingCommit;
-   bool mWaylandBufferFullScreenDamage;
-   bool mIsMainThread;
-   bool mNeedScaleFactorUpdate;
-   bool mWaitToFullScreenUpdate;
-+
-+  static bool UseDMABufBackend();
-+  static bool mUseDMABufInitialized;
-+  static bool mUseDMABuf;
- };
- 
- }  // namespace widget
+ CFLAGS += CONFIG['TK_CFLAGS']
+ CXXFLAGS += CONFIG['TK_CFLAGS']
+