Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

152 files changed, 55702 insertions, 0 deletions

diff --git a/widget/gtk/AsyncDBus.cpp b/widget/gtk/AsyncDBus.cpp
new file mode 100644
index 0000000000..cb1905dc17
--- /dev/null
+++ b/widget/gtk/AsyncDBus.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "AsyncDBus.h"
+
+#include <dbus/dbus-glib-lowlevel.h>
+#include "mozilla/UniquePtrExtensions.h"
+
+namespace mozilla::widget {
+
+static void CreateProxyCallback(GObject*, GAsyncResult* aResult,
+                                gpointer aUserData) {
+  RefPtr<DBusProxyPromise::Private> promise =
+      dont_AddRef(static_cast<DBusProxyPromise::Private*>(aUserData));
+  GUniquePtr<GError> error;
+  RefPtr<GDBusProxy> proxy = dont_AddRef(
+      g_dbus_proxy_new_for_bus_finish(aResult, getter_Transfers(error)));
+  if (proxy) {
+    promise->Resolve(std::move(proxy), __func__);
+  } else {
+    promise->Reject(std::move(error), __func__);
+  }
+}
+
+RefPtr<DBusProxyPromise> CreateDBusProxyForBus(
+    GBusType aBusType, GDBusProxyFlags aFlags,
+    GDBusInterfaceInfo* aInterfaceInfo, const char* aName,
+    const char* aObjectPath, const char* aInterfaceName,
+    GCancellable* aCancellable) {
+  auto promise = MakeRefPtr<DBusProxyPromise::Private>(__func__);
+  g_dbus_proxy_new_for_bus(aBusType, aFlags, aInterfaceInfo, aName, aObjectPath,
+                           aInterfaceName, aCancellable, CreateProxyCallback,
+                           do_AddRef(promise).take());
+  return promise.forget();
+}
+
+static void ProxyCallCallback(GObject* aSourceObject, GAsyncResult* aResult,
+                              gpointer aUserData) {
+  RefPtr<DBusCallPromise::Private> promise =
+      dont_AddRef(static_cast<DBusCallPromise::Private*>(aUserData));
+  GUniquePtr<GError> error;
+  RefPtr<GVariant> result = dont_AddRef(g_dbus_proxy_call_finish(
+      G_DBUS_PROXY(aSourceObject), aResult, getter_Transfers(error)));
+  if (result) {
+    promise->Resolve(std::move(result), __func__);
+  } else {
+    promise->Reject(std::move(error), __func__);
+  }
+}
+
+RefPtr<DBusCallPromise> DBusProxyCall(GDBusProxy* aProxy, const char* aMethod,
+                                      GVariant* aArgs, GDBusCallFlags aFlags,
+                                      gint aTimeout,
+                                      GCancellable* aCancellable) {
+  auto promise = MakeRefPtr<DBusCallPromise::Private>(__func__);
+  g_dbus_proxy_call(aProxy, aMethod, aArgs, aFlags, aTimeout, aCancellable,
+                    ProxyCallCallback, do_AddRef(promise).take());
+  return promise.forget();
+}
+
+static void ProxyCallWithUnixFDListCallback(GObject* aSourceObject,
+                                            GAsyncResult* aResult,
+                                            gpointer aUserData) {
+  RefPtr<DBusCallPromise::Private> promise =
+      dont_AddRef(static_cast<DBusCallPromise::Private*>(aUserData));
+  GUniquePtr<GError> error;
+  GUnixFDList** aFDList = nullptr;
+  RefPtr<GVariant> result =
+      dont_AddRef(g_dbus_proxy_call_with_unix_fd_list_finish(
+          G_DBUS_PROXY(aSourceObject), aFDList, aResult,
+          getter_Transfers(error)));
+  if (result) {
+    promise->Resolve(std::move(result), __func__);
+  } else {
+    promise->Reject(std::move(error), __func__);
+  }
+}
+
+RefPtr<DBusCallPromise> DBusProxyCallWithUnixFDList(
+    GDBusProxy* aProxy, const char* aMethod, GVariant* aArgs,
+    GDBusCallFlags aFlags, gint aTimeout, GUnixFDList* aFDList,
+    GCancellable* aCancellable) {
+  auto promise = MakeRefPtr<DBusCallPromise::Private>(__func__);
+  g_dbus_proxy_call_with_unix_fd_list(
+      aProxy, aMethod, aArgs, aFlags, aTimeout, aFDList, aCancellable,
+      ProxyCallWithUnixFDListCallback, do_AddRef(promise).take());
+  return promise.forget();
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/AsyncDBus.h b/widget/gtk/AsyncDBus.h
new file mode 100644
index 0000000000..41558c8d70
--- /dev/null
+++ b/widget/gtk/AsyncDBus.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_widget_AsyncDBus_h
+#define mozilla_widget_AsyncDBus_h
+
+#include <dbus/dbus-glib.h>
+
+#include "mozilla/GRefPtr.h"
+#include "mozilla/GUniquePtr.h"
+#include "mozilla/MozPromise.h"
+
+namespace mozilla::widget {
+
+using DBusProxyPromise = MozPromise<RefPtr<GDBusProxy>, GUniquePtr<GError>,
+                                    /* IsExclusive = */ true>;
+
+using DBusCallPromise = MozPromise<RefPtr<GVariant>, GUniquePtr<GError>,
+                                   /* IsExclusive = */ true>;
+
+RefPtr<DBusProxyPromise> CreateDBusProxyForBus(
+    GBusType aBusType, GDBusProxyFlags aFlags,
+    GDBusInterfaceInfo* aInterfaceInfo, const char* aName,
+    const char* aObjectPath, const char* aInterfaceName,
+    GCancellable* aCancellable = nullptr);
+
+RefPtr<DBusCallPromise> DBusProxyCall(GDBusProxy*, const char* aMethod,
+                                      GVariant* aArgs, GDBusCallFlags,
+                                      gint aTimeout = -1,
+                                      GCancellable* = nullptr);
+
+RefPtr<DBusCallPromise> DBusProxyCallWithUnixFDList(
+    GDBusProxy*, const char* aMethod, GVariant* aArgs, GDBusCallFlags,
+    gint aTimeout = -1, GUnixFDList* = nullptr, GCancellable* = nullptr);
+
+}  // namespace mozilla::widget
+
+#endif
diff --git a/widget/gtk/AsyncGtkClipboardRequest.cpp b/widget/gtk/AsyncGtkClipboardRequest.cpp
new file mode 100644
index 0000000000..75801c698d
--- /dev/null
+++ b/widget/gtk/AsyncGtkClipboardRequest.cpp
@@ -0,0 +1,120 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "AsyncGtkClipboardRequest.h"
+
+namespace mozilla {
+
+AsyncGtkClipboardRequest::AsyncGtkClipboardRequest(ClipboardDataType aDataType,
+                                                   int32_t aWhichClipboard,
+                                                   const char* aMimeType) {
+  GtkClipboard* clipboard =
+      gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
+  mRequest = MakeUnique<Request>(aDataType);
+
+  switch (aDataType) {
+    case ClipboardDataType::Data:
+      LOGCLIP("  getting DATA MIME %s\n", aMimeType);
+      gtk_clipboard_request_contents(clipboard,
+                                     gdk_atom_intern(aMimeType, FALSE),
+                                     OnDataReceived, mRequest.get());
+      break;
+    case ClipboardDataType::Text:
+      LOGCLIP("  getting TEXT\n");
+      gtk_clipboard_request_text(clipboard, OnTextReceived, mRequest.get());
+      break;
+    case ClipboardDataType::Targets:
+      LOGCLIP("  getting TARGETS\n");
+      gtk_clipboard_request_contents(clipboard,
+                                     gdk_atom_intern("TARGETS", FALSE),
+                                     OnDataReceived, mRequest.get());
+      break;
+  }
+}
+
+void AsyncGtkClipboardRequest::OnDataReceived(GtkClipboard* clipboard,
+                                              GtkSelectionData* selection_data,
+                                              gpointer data) {
+  int whichClipboard = GetGeckoClipboardType(clipboard);
+  LOGCLIP("OnDataReceived(%s) callback\n",
+          whichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                             : "clipboard");
+  static_cast<Request*>(data)->Complete(selection_data);
+}
+
+void AsyncGtkClipboardRequest::OnTextReceived(GtkClipboard* clipboard,
+                                              const gchar* text,
+                                              gpointer data) {
+  int whichClipboard = GetGeckoClipboardType(clipboard);
+  LOGCLIP("OnTextReceived(%s) callback\n",
+          whichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                             : "clipboard");
+  static_cast<Request*>(data)->Complete(text);
+}
+
+void AsyncGtkClipboardRequest::Request::Complete(const void* aData) {
+  LOGCLIP("Request::Complete(), aData = %p, timedOut = %d\n", aData, mTimedOut);
+
+  if (mTimedOut) {
+    delete this;
+    return;
+  }
+
+  mData.emplace();
+
+  gint dataLength = 0;
+  if (mDataType == ClipboardDataType::Targets ||
+      mDataType == ClipboardDataType::Data) {
+    dataLength = gtk_selection_data_get_length((GtkSelectionData*)aData);
+  } else {
+    dataLength = aData ? strlen((const char*)aData) : 0;
+  }
+
+  // Negative size means no data or data error.
+  if (dataLength <= 0) {
+    LOGCLIP("    zero dataLength, quit.\n");
+    return;
+  }
+
+  switch (mDataType) {
+    case ClipboardDataType::Targets: {
+      LOGCLIP("    getting %d bytes of clipboard targets.\n", dataLength);
+      gint n_targets = 0;
+      GdkAtom* targets = nullptr;
+      if (!gtk_selection_data_get_targets((GtkSelectionData*)aData, &targets,
+                                          &n_targets) ||
+          !n_targets) {
+        // We failed to get targets
+        return;
+      }
+      mData->SetTargets(
+          ClipboardTargets{GUniquePtr<GdkAtom>(targets), uint32_t(n_targets)});
+      break;
+    }
+    case ClipboardDataType::Text: {
+      LOGCLIP("    getting %d bytes of text.\n", dataLength);
+      mData->SetText(Span(static_cast<const char*>(aData), dataLength));
+      LOGCLIP("    done, mClipboardData = %p\n", mData->AsSpan().data());
+      break;
+    }
+    case ClipboardDataType::Data: {
+      LOGCLIP("    getting %d bytes of data.\n", dataLength);
+      mData->SetData(Span(gtk_selection_data_get_data((GtkSelectionData*)aData),
+                          dataLength));
+      LOGCLIP("    done, mClipboardData = %p\n", mData->AsSpan().data());
+      break;
+    }
+  }
+}
+
+AsyncGtkClipboardRequest::~AsyncGtkClipboardRequest() {
+  if (mRequest && mRequest->mData.isNothing()) {
+    mRequest->mTimedOut = true;
+    Unused << mRequest.release();
+  }
+}
+
+}  // namespace mozilla
diff --git a/widget/gtk/AsyncGtkClipboardRequest.h b/widget/gtk/AsyncGtkClipboardRequest.h
new file mode 100644
index 0000000000..1d72691560
--- /dev/null
+++ b/widget/gtk/AsyncGtkClipboardRequest.h
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_AsyncGtkClipboardRequest_h
+#define mozilla_AsyncGtkClipboardRequest_h
+
+#include "nsClipboard.h"
+
+namespace mozilla {
+
+// An asynchronous clipboard request that we wait for synchronously by
+// spinning the event loop.
+class MOZ_STACK_CLASS AsyncGtkClipboardRequest {
+  // Heap-allocated object that we give GTK as a callback.
+  struct Request {
+    explicit Request(ClipboardDataType aDataType) : mDataType(aDataType) {}
+
+    void Complete(const void*);
+
+    const ClipboardDataType mDataType;
+    Maybe<ClipboardData> mData;
+    bool mTimedOut = false;
+  };
+
+  UniquePtr<Request> mRequest;
+
+  static void OnDataReceived(GtkClipboard*, GtkSelectionData*, gpointer);
+  static void OnTextReceived(GtkClipboard*, const gchar*, gpointer);
+
+ public:
+  // Launch a request for a particular GTK clipboard. The current status of the
+  // request can be observed by calling HasCompleted() and TakeResult().
+  AsyncGtkClipboardRequest(ClipboardDataType, int32_t aWhichClipboard,
+                           const char* aMimeType = nullptr);
+
+  // Returns whether the request has been answered already.
+  bool HasCompleted() const { return mRequest->mData.isSome(); }
+
+  // Takes the result from the current request if completed, or a
+  // default-constructed data otherwise. The destructor will take care of
+  // flagging the request as timed out in that case.
+  ClipboardData TakeResult() {
+    if (!HasCompleted()) {
+      return {};
+    }
+    auto request = std::move(mRequest);
+    return request->mData.extract();
+  }
+
+  // If completed, frees the request if needed. Otherwise, marks it as a timed
+  // out request so that when it completes the Request object is properly
+  // freed.
+  ~AsyncGtkClipboardRequest();
+};
+
+};  // namespace mozilla
+
+#endif
diff --git a/widget/gtk/CompositorWidgetChild.cpp b/widget/gtk/CompositorWidgetChild.cpp
new file mode 100644
index 0000000000..b7908a43d4
--- /dev/null
+++ b/widget/gtk/CompositorWidgetChild.cpp
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "CompositorWidgetChild.h"
+#include "mozilla/Unused.h"
+#include "gfxPlatform.h"
+
+namespace mozilla {
+namespace widget {
+
+CompositorWidgetChild::CompositorWidgetChild(
+    RefPtr<CompositorVsyncDispatcher> aVsyncDispatcher,
+    RefPtr<CompositorWidgetVsyncObserver> aVsyncObserver,
+    const CompositorWidgetInitData&)
+    : mVsyncDispatcher(aVsyncDispatcher), mVsyncObserver(aVsyncObserver) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(!gfxPlatform::IsHeadless());
+}
+
+CompositorWidgetChild::~CompositorWidgetChild() = default;
+
+bool CompositorWidgetChild::Initialize() { return true; }
+
+mozilla::ipc::IPCResult CompositorWidgetChild::RecvObserveVsync() {
+  mVsyncDispatcher->SetCompositorVsyncObserver(mVsyncObserver);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult CompositorWidgetChild::RecvUnobserveVsync() {
+  mVsyncDispatcher->SetCompositorVsyncObserver(nullptr);
+  return IPC_OK();
+}
+
+void CompositorWidgetChild::NotifyClientSizeChanged(
+    const LayoutDeviceIntSize& aClientSize) {
+  Unused << SendNotifyClientSizeChanged(aClientSize);
+}
+
+void CompositorWidgetChild::DisableRendering() {
+  Unused << SendDisableRendering();
+}
+
+void CompositorWidgetChild::EnableRendering(const uintptr_t aXWindow,
+                                            const bool aShaped) {
+  Unused << SendEnableRendering(aXWindow, aShaped);
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/CompositorWidgetChild.h b/widget/gtk/CompositorWidgetChild.h
new file mode 100644
index 0000000000..b1cad75da3
--- /dev/null
+++ b/widget/gtk/CompositorWidgetChild.h
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef widget_gtk_CompositorWidgetChild_h
+#define widget_gtk_CompositorWidgetChild_h
+
+#include "GtkCompositorWidget.h"
+#include "mozilla/widget/PCompositorWidgetChild.h"
+#include "mozilla/widget/CompositorWidgetVsyncObserver.h"
+
+namespace mozilla {
+namespace widget {
+
+class CompositorWidgetChild final : public PCompositorWidgetChild,
+                                    public PlatformCompositorWidgetDelegate {
+ public:
+  CompositorWidgetChild(RefPtr<CompositorVsyncDispatcher> aVsyncDispatcher,
+                        RefPtr<CompositorWidgetVsyncObserver> aVsyncObserver,
+                        const CompositorWidgetInitData&);
+  ~CompositorWidgetChild() override;
+
+  bool Initialize();
+
+  mozilla::ipc::IPCResult RecvObserveVsync() override;
+  mozilla::ipc::IPCResult RecvUnobserveVsync() override;
+
+  void NotifyClientSizeChanged(const LayoutDeviceIntSize& aClientSize) override;
+  void DisableRendering() override;
+  void EnableRendering(const uintptr_t aXWindow, const bool aShaped) override;
+
+ private:
+  RefPtr<CompositorVsyncDispatcher> mVsyncDispatcher;
+  RefPtr<CompositorWidgetVsyncObserver> mVsyncObserver;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // widget_gtk_CompositorWidgetChild_h
diff --git a/widget/gtk/CompositorWidgetParent.cpp b/widget/gtk/CompositorWidgetParent.cpp
new file mode 100644
index 0000000000..998614622e
--- /dev/null
+++ b/widget/gtk/CompositorWidgetParent.cpp
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "CompositorWidgetParent.h"
+#include "mozilla/Unused.h"
+#include "mozilla/widget/PlatformWidgetTypes.h"
+#include "nsWindow.h"
+
+namespace mozilla::widget {
+
+CompositorWidgetParent::CompositorWidgetParent(
+    const CompositorWidgetInitData& aInitData,
+    const layers::CompositorOptions& aOptions)
+    : GtkCompositorWidget(aInitData.get_GtkCompositorWidgetInitData(), aOptions,
+                          nullptr) {
+  MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_GPU);
+}
+
+CompositorWidgetParent::~CompositorWidgetParent() = default;
+
+void CompositorWidgetParent::ObserveVsync(VsyncObserver* aObserver) {
+  if (aObserver) {
+    Unused << SendObserveVsync();
+  } else {
+    Unused << SendUnobserveVsync();
+  }
+  mVsyncObserver = aObserver;
+}
+
+RefPtr<VsyncObserver> CompositorWidgetParent::GetVsyncObserver() const {
+  MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_GPU);
+  return mVsyncObserver;
+}
+
+mozilla::ipc::IPCResult CompositorWidgetParent::RecvNotifyClientSizeChanged(
+    const LayoutDeviceIntSize& aClientSize) {
+  NotifyClientSizeChanged(aClientSize);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult CompositorWidgetParent::RecvDisableRendering() {
+  DisableRendering();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult CompositorWidgetParent::RecvEnableRendering(
+    const uintptr_t& aXWindow, const bool& aShaped) {
+  EnableRendering(aXWindow, aShaped);
+  return IPC_OK();
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/CompositorWidgetParent.h b/widget/gtk/CompositorWidgetParent.h
new file mode 100644
index 0000000000..2bbc70af3e
--- /dev/null
+++ b/widget/gtk/CompositorWidgetParent.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef widget_gtk_CompositorWidgetParent_h
+#define widget_gtk_CompositorWidgetParent_h
+
+#include "GtkCompositorWidget.h"
+#include "mozilla/VsyncDispatcher.h"
+#include "mozilla/widget/PCompositorWidgetParent.h"
+
+namespace mozilla {
+namespace widget {
+
+class CompositorWidgetParent final : public PCompositorWidgetParent,
+                                     public GtkCompositorWidget {
+ public:
+  explicit CompositorWidgetParent(const CompositorWidgetInitData& aInitData,
+                                  const layers::CompositorOptions& aOptions);
+  ~CompositorWidgetParent() override;
+
+  void ActorDestroy(ActorDestroyReason aWhy) override {}
+
+  void ObserveVsync(VsyncObserver* aObserver) override;
+  RefPtr<VsyncObserver> GetVsyncObserver() const override;
+
+  mozilla::ipc::IPCResult RecvNotifyClientSizeChanged(
+      const LayoutDeviceIntSize& aClientSize) override;
+
+  mozilla::ipc::IPCResult RecvDisableRendering() override;
+  mozilla::ipc::IPCResult RecvEnableRendering(const uintptr_t& aXWindow,
+                                              const bool& aShaped) override;
+
+ private:
+  RefPtr<VsyncObserver> mVsyncObserver;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // widget_gtk_CompositorWidgetParent_h
diff --git a/widget/gtk/DMABufLibWrapper.cpp b/widget/gtk/DMABufLibWrapper.cpp
new file mode 100644
index 0000000000..c690ffa331
--- /dev/null
+++ b/widget/gtk/DMABufLibWrapper.cpp
@@ -0,0 +1,331 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "base/message_loop.h"  // for MessageLoop
+#include "nsWaylandDisplay.h"
+#include "DMABufLibWrapper.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "WidgetUtilsGtk.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dlfcn.h>
+
+namespace mozilla {
+namespace widget {
+
+#define GBMLIB_NAME "libgbm.so.1"
+#define DRMLIB_NAME "libdrm.so.2"
+
+// Use static lock to protect dri operation as
+// gbm_dri.c is not thread safe.
+// https://gitlab.freedesktop.org/mesa/mesa/-/issues/4422
+mozilla::StaticMutex nsGbmLib::sDRILock MOZ_UNANNOTATED;
+
+bool nsGbmLib::sLoaded = false;
+void* nsGbmLib::sGbmLibHandle = nullptr;
+void* nsGbmLib::sXf86DrmLibHandle = nullptr;
+CreateDeviceFunc nsGbmLib::sCreateDevice;
+DestroyDeviceFunc nsGbmLib::sDestroyDevice;
+CreateFunc nsGbmLib::sCreate;
+CreateWithModifiersFunc nsGbmLib::sCreateWithModifiers;
+GetModifierFunc nsGbmLib::sGetModifier;
+GetStrideFunc nsGbmLib::sGetStride;
+GetFdFunc nsGbmLib::sGetFd;
+DestroyFunc nsGbmLib::sDestroy;
+MapFunc nsGbmLib::sMap;
+UnmapFunc nsGbmLib::sUnmap;
+GetPlaneCountFunc nsGbmLib::sGetPlaneCount;
+GetHandleForPlaneFunc nsGbmLib::sGetHandleForPlane;
+GetStrideForPlaneFunc nsGbmLib::sGetStrideForPlane;
+GetOffsetFunc nsGbmLib::sGetOffset;
+DeviceIsFormatSupportedFunc nsGbmLib::sDeviceIsFormatSupported;
+DrmPrimeHandleToFDFunc nsGbmLib::sDrmPrimeHandleToFD;
+CreateSurfaceFunc nsGbmLib::sCreateSurface;
+DestroySurfaceFunc nsGbmLib::sDestroySurface;
+
+bool nsGbmLib::IsLoaded() {
+  return sCreateDevice != nullptr && sDestroyDevice != nullptr &&
+         sCreate != nullptr && sCreateWithModifiers != nullptr &&
+         sGetModifier != nullptr && sGetStride != nullptr &&
+         sGetFd != nullptr && sDestroy != nullptr && sMap != nullptr &&
+         sUnmap != nullptr && sGetPlaneCount != nullptr &&
+         sGetHandleForPlane != nullptr && sGetStrideForPlane != nullptr &&
+         sGetOffset != nullptr && sDeviceIsFormatSupported != nullptr &&
+         sDrmPrimeHandleToFD != nullptr && sCreateSurface != nullptr &&
+         sDestroySurface != nullptr;
+}
+
+bool nsGbmLib::Load() {
+  static bool sTriedToLoad = false;
+  if (sTriedToLoad) {
+    return sLoaded;
+  }
+
+  sTriedToLoad = true;
+
+  MOZ_ASSERT(!sGbmLibHandle);
+  MOZ_ASSERT(!sLoaded);
+
+  LOGDMABUF(("Loading DMABuf system library %s ...\n", GBMLIB_NAME));
+
+  sGbmLibHandle = dlopen(GBMLIB_NAME, RTLD_LAZY | RTLD_LOCAL);
+  if (!sGbmLibHandle) {
+    LOGDMABUF(("Failed to load %s, dmabuf isn't available.\n", GBMLIB_NAME));
+    return false;
+  }
+
+  sCreateDevice = (CreateDeviceFunc)dlsym(sGbmLibHandle, "gbm_create_device");
+  sDestroyDevice =
+      (DestroyDeviceFunc)dlsym(sGbmLibHandle, "gbm_device_destroy");
+  sCreate = (CreateFunc)dlsym(sGbmLibHandle, "gbm_bo_create");
+  sCreateWithModifiers = (CreateWithModifiersFunc)dlsym(
+      sGbmLibHandle, "gbm_bo_create_with_modifiers");
+  sGetModifier = (GetModifierFunc)dlsym(sGbmLibHandle, "gbm_bo_get_modifier");
+  sGetStride = (GetStrideFunc)dlsym(sGbmLibHandle, "gbm_bo_get_stride");
+  sGetFd = (GetFdFunc)dlsym(sGbmLibHandle, "gbm_bo_get_fd");
+  sDestroy = (DestroyFunc)dlsym(sGbmLibHandle, "gbm_bo_destroy");
+  sMap = (MapFunc)dlsym(sGbmLibHandle, "gbm_bo_map");
+  sUnmap = (UnmapFunc)dlsym(sGbmLibHandle, "gbm_bo_unmap");
+  sGetPlaneCount =
+      (GetPlaneCountFunc)dlsym(sGbmLibHandle, "gbm_bo_get_plane_count");
+  sGetHandleForPlane = (GetHandleForPlaneFunc)dlsym(
+      sGbmLibHandle, "gbm_bo_get_handle_for_plane");
+  sGetStrideForPlane = (GetStrideForPlaneFunc)dlsym(
+      sGbmLibHandle, "gbm_bo_get_stride_for_plane");
+  sGetOffset = (GetOffsetFunc)dlsym(sGbmLibHandle, "gbm_bo_get_offset");
+  sDeviceIsFormatSupported = (DeviceIsFormatSupportedFunc)dlsym(
+      sGbmLibHandle, "gbm_device_is_format_supported");
+  sCreateSurface =
+      (CreateSurfaceFunc)dlsym(sGbmLibHandle, "gbm_surface_create");
+  sDestroySurface =
+      (DestroySurfaceFunc)dlsym(sGbmLibHandle, "gbm_surface_destroy");
+
+  sXf86DrmLibHandle = dlopen(DRMLIB_NAME, RTLD_LAZY | RTLD_LOCAL);
+  if (!sXf86DrmLibHandle) {
+    LOGDMABUF(("Failed to load %s, dmabuf isn't available.\n", DRMLIB_NAME));
+    return false;
+  }
+  sDrmPrimeHandleToFD =
+      (DrmPrimeHandleToFDFunc)dlsym(sXf86DrmLibHandle, "drmPrimeHandleToFD");
+  sLoaded = IsLoaded();
+  if (!sLoaded) {
+    LOGDMABUF(("Failed to load all symbols from %s\n", GBMLIB_NAME));
+  }
+  return sLoaded;
+}
+
+gbm_device* nsDMABufDevice::GetGbmDevice() { return mGbmDevice; }
+
+static void dmabuf_modifiers(void* data,
+                             struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf,
+                             uint32_t format, uint32_t modifier_hi,
+                             uint32_t modifier_lo) {
+  // skip modifiers marked as invalid
+  if (modifier_hi == (DRM_FORMAT_MOD_INVALID >> 32) &&
+      modifier_lo == (DRM_FORMAT_MOD_INVALID & 0xffffffff)) {
+    return;
+  }
+
+  auto* device = static_cast<nsDMABufDevice*>(data);
+  switch (format) {
+    case GBM_FORMAT_ARGB8888:
+      device->AddFormatModifier(true, format, modifier_hi, modifier_lo);
+      break;
+    case GBM_FORMAT_XRGB8888:
+      device->AddFormatModifier(false, format, modifier_hi, modifier_lo);
+      break;
+    default:
+      break;
+  }
+}
+
+static void dmabuf_format(void* data,
+                          struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf,
+                          uint32_t format) {
+  // XXX: deprecated
+}
+
+static const struct zwp_linux_dmabuf_v1_listener dmabuf_listener = {
+    dmabuf_format, dmabuf_modifiers};
+
+static void global_registry_handler(void* data, wl_registry* registry,
+                                    uint32_t id, const char* interface,
+                                    uint32_t version) {
+  auto* device = static_cast<nsDMABufDevice*>(data);
+  if (strcmp(interface, "zwp_linux_dmabuf_v1") == 0 && version > 2) {
+    auto* dmabuf = WaylandRegistryBind<zwp_linux_dmabuf_v1>(
+        registry, id, &zwp_linux_dmabuf_v1_interface, 3);
+    LOGDMABUF(("zwp_linux_dmabuf_v1 is available."));
+    device->ResetFormatsModifiers();
+    zwp_linux_dmabuf_v1_add_listener(dmabuf, &dmabuf_listener, data);
+  } else if (strcmp(interface, "wl_drm") == 0) {
+    LOGDMABUF(("wl_drm is available."));
+  }
+}
+
+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};
+
+nsDMABufDevice::nsDMABufDevice()
+    : mUseWebGLDmabufBackend(true),
+      mXRGBFormat({true, false, GBM_FORMAT_XRGB8888, nullptr, 0}),
+      mARGBFormat({true, true, GBM_FORMAT_ARGB8888, nullptr, 0}),
+      mDRMFd(-1),
+      mGbmDevice(nullptr),
+      mInitialized(false) {
+  if (GdkIsWaylandDisplay()) {
+    wl_display* display = WaylandDisplayGetWLDisplay();
+    wl_registry* registry = wl_display_get_registry(display);
+    wl_registry_add_listener(registry, &registry_listener, this);
+    wl_display_roundtrip(display);
+    wl_display_roundtrip(display);
+    wl_registry_destroy(registry);
+  }
+
+  nsAutoCString drm_render_node(getenv("MOZ_DRM_DEVICE"));
+  if (drm_render_node.IsEmpty()) {
+    drm_render_node.Assign(gfx::gfxVars::DrmRenderDevice());
+  }
+
+  if (!drm_render_node.IsEmpty()) {
+    LOGDMABUF(("Using DRM device %s", drm_render_node.get()));
+    mDRMFd = open(drm_render_node.get(), O_RDWR);
+    if (mDRMFd < 0) {
+      LOGDMABUF(("Failed to open drm render node %s error %s\n",
+                 drm_render_node.get(), strerror(errno)));
+    }
+  } else {
+    LOGDMABUF(("We're missing DRM render device!\n"));
+  }
+}
+
+nsDMABufDevice::~nsDMABufDevice() {
+  if (mGbmDevice) {
+    nsGbmLib::DestroyDevice(mGbmDevice);
+    mGbmDevice = nullptr;
+  }
+  if (mDRMFd != -1) {
+    close(mDRMFd);
+    mDRMFd = -1;
+  }
+}
+
+int nsDMABufDevice::GetDRMFd() { return mDRMFd; }
+
+bool nsDMABufDevice::Configure(nsACString& aFailureId) {
+  LOGDMABUF(("nsDMABufDevice::Configure()"));
+
+  MOZ_ASSERT(!mInitialized);
+  mInitialized = true;
+
+  bool isDMABufUsed = (
+#ifdef NIGHTLY_BUILD
+      StaticPrefs::widget_dmabuf_textures_enabled() ||
+#endif
+      StaticPrefs::widget_dmabuf_webgl_enabled());
+
+  if (!isDMABufUsed) {
+    // Disabled by user, just quit.
+    LOGDMABUF(("IsDMABufEnabled(): Disabled by preferences."));
+    aFailureId = "FEATURE_FAILURE_NO_PREFS_ENABLED";
+    return false;
+  }
+
+  if (!nsGbmLib::IsAvailable()) {
+    LOGDMABUF(("nsGbmLib is not available!"));
+    aFailureId = "FEATURE_FAILURE_NO_LIBGBM";
+    return false;
+  }
+
+  // fd passed to gbm_create_device() should be kept open until
+  // gbm_device_destroy() is called.
+  mGbmDevice = nsGbmLib::CreateDevice(GetDRMFd());
+  if (!mGbmDevice) {
+    LOGDMABUF(("Failed to create drm render device"));
+    aFailureId = "FEATURE_FAILURE_BAD_DRM_RENDER_NODE";
+    return false;
+  }
+
+  LOGDMABUF(("DMABuf is enabled"));
+  return true;
+}
+
+#ifdef NIGHTLY_BUILD
+bool nsDMABufDevice::IsDMABufTexturesEnabled() {
+  return gfx::gfxVars::UseDMABuf() &&
+         StaticPrefs::widget_dmabuf_textures_enabled();
+}
+#else
+bool nsDMABufDevice::IsDMABufTexturesEnabled() { return false; }
+#endif
+bool nsDMABufDevice::IsDMABufWebGLEnabled() {
+  LOGDMABUF(
+      ("nsDMABufDevice::IsDMABufWebGLEnabled: UseDMABuf %d "
+       "mUseWebGLDmabufBackend %d "
+       "widget_dmabuf_webgl_enabled %d\n",
+       gfx::gfxVars::UseDMABuf(), mUseWebGLDmabufBackend,
+       StaticPrefs::widget_dmabuf_webgl_enabled()));
+  return gfx::gfxVars::UseDMABuf() && mUseWebGLDmabufBackend &&
+         StaticPrefs::widget_dmabuf_webgl_enabled();
+}
+
+void nsDMABufDevice::DisableDMABufWebGL() { mUseWebGLDmabufBackend = false; }
+
+GbmFormat* nsDMABufDevice::GetGbmFormat(bool aHasAlpha) {
+  GbmFormat* format = aHasAlpha ? &mARGBFormat : &mXRGBFormat;
+  return format->mIsSupported ? format : nullptr;
+}
+
+GbmFormat* nsDMABufDevice::GetExactGbmFormat(int aFormat) {
+  if (aFormat == mARGBFormat.mFormat) {
+    return &mARGBFormat;
+  } else if (aFormat == mXRGBFormat.mFormat) {
+    return &mXRGBFormat;
+  }
+
+  return nullptr;
+}
+
+void nsDMABufDevice::AddFormatModifier(bool aHasAlpha, int aFormat,
+                                       uint32_t mModifierHi,
+                                       uint32_t mModifierLo) {
+  GbmFormat* format = aHasAlpha ? &mARGBFormat : &mXRGBFormat;
+  format->mIsSupported = true;
+  format->mHasAlpha = aHasAlpha;
+  format->mFormat = aFormat;
+  format->mModifiersCount++;
+  format->mModifiers =
+      (uint64_t*)realloc(format->mModifiers,
+                         format->mModifiersCount * sizeof(*format->mModifiers));
+  format->mModifiers[format->mModifiersCount - 1] =
+      ((uint64_t)mModifierHi << 32) | mModifierLo;
+}
+
+void nsDMABufDevice::ResetFormatsModifiers() {
+  mARGBFormat.mModifiersCount = 0;
+  free(mARGBFormat.mModifiers);
+  mARGBFormat.mModifiers = nullptr;
+
+  mXRGBFormat.mModifiersCount = 0;
+  free(mXRGBFormat.mModifiers);
+  mXRGBFormat.mModifiers = nullptr;
+}
+
+nsDMABufDevice* GetDMABufDevice() {
+  static nsDMABufDevice dmaBufDevice;
+  return &dmaBufDevice;
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/DMABufLibWrapper.h b/widget/gtk/DMABufLibWrapper.h
new file mode 100644
index 0000000000..57270bffc3
--- /dev/null
+++ b/widget/gtk/DMABufLibWrapper.h
@@ -0,0 +1,222 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __MOZ_DMABUF_LIB_WRAPPER_H__
+#define __MOZ_DMABUF_LIB_WRAPPER_H__
+
+#include "mozilla/widget/gbm.h"
+#include "mozilla/StaticMutex.h"
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gDmabufLog;
+#  define LOGDMABUF(args) MOZ_LOG(gDmabufLog, mozilla::LogLevel::Debug, args)
+#else
+#  define LOGDMABUF(args)
+#endif /* MOZ_LOGGING */
+
+#ifndef DRM_FORMAT_MOD_INVALID
+#  define DRM_FORMAT_MOD_INVALID ((1ULL << 56) - 1)
+#endif
+
+namespace mozilla {
+namespace widget {
+
+typedef struct gbm_device* (*CreateDeviceFunc)(int);
+typedef void (*DestroyDeviceFunc)(struct gbm_device*);
+typedef struct gbm_bo* (*CreateFunc)(struct gbm_device*, uint32_t, uint32_t,
+                                     uint32_t, uint32_t);
+typedef struct gbm_bo* (*CreateWithModifiersFunc)(struct gbm_device*, uint32_t,
+                                                  uint32_t, uint32_t,
+                                                  const uint64_t*,
+                                                  const unsigned int);
+typedef uint64_t (*GetModifierFunc)(struct gbm_bo*);
+typedef uint32_t (*GetStrideFunc)(struct gbm_bo*);
+typedef int (*GetFdFunc)(struct gbm_bo*);
+typedef void (*DestroyFunc)(struct gbm_bo*);
+typedef void* (*MapFunc)(struct gbm_bo*, uint32_t, uint32_t, uint32_t, uint32_t,
+                         uint32_t, uint32_t*, void**);
+typedef void (*UnmapFunc)(struct gbm_bo*, void*);
+typedef int (*GetPlaneCountFunc)(struct gbm_bo*);
+typedef union gbm_bo_handle (*GetHandleForPlaneFunc)(struct gbm_bo*, int);
+typedef uint32_t (*GetStrideForPlaneFunc)(struct gbm_bo*, int);
+typedef uint32_t (*GetOffsetFunc)(struct gbm_bo*, int);
+typedef int (*DeviceIsFormatSupportedFunc)(struct gbm_device*, uint32_t,
+                                           uint32_t);
+typedef int (*DrmPrimeHandleToFDFunc)(int, uint32_t, uint32_t, int*);
+typedef struct gbm_surface* (*CreateSurfaceFunc)(struct gbm_device*, uint32_t,
+                                                 uint32_t, uint32_t, uint32_t);
+typedef void (*DestroySurfaceFunc)(struct gbm_surface*);
+
+class nsGbmLib {
+ public:
+  static bool IsAvailable() { return sLoaded || Load(); }
+  static bool IsModifierAvailable();
+
+  static struct gbm_device* CreateDevice(int fd) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sCreateDevice(fd);
+  };
+  static void DestroyDevice(struct gbm_device* gdm) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sDestroyDevice(gdm);
+  };
+  static struct gbm_bo* Create(struct gbm_device* gbm, uint32_t width,
+                               uint32_t height, uint32_t format,
+                               uint32_t flags) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sCreate(gbm, width, height, format, flags);
+  }
+  static void Destroy(struct gbm_bo* bo) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    sDestroy(bo);
+  }
+  static uint32_t GetStride(struct gbm_bo* bo) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetStride(bo);
+  }
+  static int GetFd(struct gbm_bo* bo) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetFd(bo);
+  }
+  static void* Map(struct gbm_bo* bo, uint32_t x, uint32_t y, uint32_t width,
+                   uint32_t height, uint32_t flags, uint32_t* stride,
+                   void** map_data) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sMap(bo, x, y, width, height, flags, stride, map_data);
+  }
+  static void Unmap(struct gbm_bo* bo, void* map_data) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    sUnmap(bo, map_data);
+  }
+  static struct gbm_bo* CreateWithModifiers(struct gbm_device* gbm,
+                                            uint32_t width, uint32_t height,
+                                            uint32_t format,
+                                            const uint64_t* modifiers,
+                                            const unsigned int count) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sCreateWithModifiers(gbm, width, height, format, modifiers, count);
+  }
+  static uint64_t GetModifier(struct gbm_bo* bo) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetModifier(bo);
+  }
+  static int GetPlaneCount(struct gbm_bo* bo) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetPlaneCount(bo);
+  }
+  static union gbm_bo_handle GetHandleForPlane(struct gbm_bo* bo, int plane) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetHandleForPlane(bo, plane);
+  }
+  static uint32_t GetStrideForPlane(struct gbm_bo* bo, int plane) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetStrideForPlane(bo, plane);
+  }
+  static uint32_t GetOffset(struct gbm_bo* bo, int plane) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sGetOffset(bo, plane);
+  }
+  static int DeviceIsFormatSupported(struct gbm_device* gbm, uint32_t format,
+                                     uint32_t usage) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sDeviceIsFormatSupported(gbm, format, usage);
+  }
+  static int DrmPrimeHandleToFD(int fd, uint32_t handle, uint32_t flags,
+                                int* prime_fd) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sDrmPrimeHandleToFD(fd, handle, flags, prime_fd);
+  }
+  static struct gbm_surface* CreateSurface(struct gbm_device* gbm,
+                                           uint32_t width, uint32_t height,
+                                           uint32_t format, uint32_t flags) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sCreateSurface(gbm, width, height, format, flags);
+  }
+  static void DestroySurface(struct gbm_surface* surface) {
+    StaticMutexAutoLock lockDRI(sDRILock);
+    return sDestroySurface(surface);
+  }
+
+ private:
+  static bool Load();
+  static bool IsLoaded();
+
+  static CreateDeviceFunc sCreateDevice;
+  static DestroyDeviceFunc sDestroyDevice;
+  static CreateFunc sCreate;
+  static CreateWithModifiersFunc sCreateWithModifiers;
+  static GetModifierFunc sGetModifier;
+  static GetStrideFunc sGetStride;
+  static GetFdFunc sGetFd;
+  static DestroyFunc sDestroy;
+  static MapFunc sMap;
+  static UnmapFunc sUnmap;
+  static GetPlaneCountFunc sGetPlaneCount;
+  static GetHandleForPlaneFunc sGetHandleForPlane;
+  static GetStrideForPlaneFunc sGetStrideForPlane;
+  static GetOffsetFunc sGetOffset;
+  static DeviceIsFormatSupportedFunc sDeviceIsFormatSupported;
+  static DrmPrimeHandleToFDFunc sDrmPrimeHandleToFD;
+  static CreateSurfaceFunc sCreateSurface;
+  static DestroySurfaceFunc sDestroySurface;
+  static bool sLoaded;
+
+  static void* sGbmLibHandle;
+  static void* sXf86DrmLibHandle;
+  static mozilla::StaticMutex sDRILock MOZ_UNANNOTATED;
+};
+
+struct GbmFormat {
+  bool mIsSupported;
+  bool mHasAlpha;
+  int mFormat;
+  uint64_t* mModifiers;
+  int mModifiersCount;
+};
+
+class nsDMABufDevice {
+ public:
+  nsDMABufDevice();
+  ~nsDMABufDevice();
+
+  gbm_device* GetGbmDevice();
+
+  // Use dmabuf for WebRender general web content
+  bool IsDMABufTexturesEnabled();
+  // Use dmabuf for WebGL content
+  bool IsDMABufWebGLEnabled();
+  void DisableDMABufWebGL();
+
+  int GetDRMFd();
+  GbmFormat* GetGbmFormat(bool aHasAlpha);
+  GbmFormat* GetExactGbmFormat(int aFormat);
+  void ResetFormatsModifiers();
+  void AddFormatModifier(bool aHasAlpha, int aFormat, uint32_t mModifierHi,
+                         uint32_t mModifierLo);
+  bool Configure(nsACString& aFailureId);
+
+ private:
+  bool mUseWebGLDmabufBackend;
+
+ private:
+  GbmFormat mXRGBFormat;
+  GbmFormat mARGBFormat;
+
+  int mDRMFd;
+  gbm_device* mGbmDevice;
+  bool mInitialized;
+};
+
+nsDMABufDevice* GetDMABufDevice();
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // __MOZ_DMABUF_LIB_WRAPPER_H__
diff --git a/widget/gtk/DMABufSurface.cpp b/widget/gtk/DMABufSurface.cpp
new file mode 100644
index 0000000000..0577e044a4
--- /dev/null
+++ b/widget/gtk/DMABufSurface.cpp
@@ -0,0 +1,1503 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "DMABufSurface.h"
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <dlfcn.h>
+#include <sys/mman.h>
+#include <sys/eventfd.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+
+#include "mozilla/widget/gbm.h"
+#include "mozilla/widget/va_drmcommon.h"
+#include "YCbCrUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "GLContextTypes.h"  // for GLContext, etc
+#include "GLContextEGL.h"
+#include "GLContextProvider.h"
+#include "ScopedGLHelpers.h"
+#include "GLBlitHelper.h"
+#include "GLReadTexImageHelper.h"
+#include "nsGtkUtils.h"
+
+#include "mozilla/layers/LayersSurfaces.h"
+#include "mozilla/ScopeExit.h"
+
+/*
+TODO:
+DRM device selection:
+https://lists.freedesktop.org/archives/wayland-devel/2018-November/039660.html
+*/
+
+/* C++ / C typecast macros for special EGL handle values */
+#if defined(__cplusplus)
+#  define EGL_CAST(type, value) (static_cast<type>(value))
+#else
+#  define EGL_CAST(type, value) ((type)(value))
+#endif
+
+using namespace mozilla;
+using namespace mozilla::widget;
+using namespace mozilla::gl;
+using namespace mozilla::layers;
+using namespace mozilla::gfx;
+
+#define BUFFER_FLAGS 0
+
+static RefPtr<GLContext> sSnapshotContext;
+static StaticMutex sSnapshotContextMutex MOZ_UNANNOTATED;
+static Atomic<int> gNewSurfaceUID(1);
+
+RefPtr<GLContext> ClaimSnapshotGLContext() {
+  if (!sSnapshotContext) {
+    nsCString discardFailureId;
+    sSnapshotContext = GLContextProvider::CreateHeadless({}, &discardFailureId);
+    if (!sSnapshotContext) {
+      LOGDMABUF(("GetAsSourceSurface: Failed to create snapshot GLContext."));
+      return nullptr;
+    }
+    sSnapshotContext->mOwningThreadId = Nothing();  // No singular owner.
+  }
+  if (!sSnapshotContext->MakeCurrent()) {
+    LOGDMABUF(("GetAsSourceSurface: Failed to make GLContext current."));
+    return nullptr;
+  }
+  return sSnapshotContext;
+}
+
+void ReturnSnapshotGLContext(RefPtr<GLContext> aGLContext) {
+  // direct eglMakeCurrent() call breaks current context caching so make sure
+  // it's not used.
+  MOZ_ASSERT(!aGLContext->mUseTLSIsCurrent);
+  if (!aGLContext->IsCurrent()) {
+    return;
+  }
+  const auto& gle = gl::GLContextEGL::Cast(aGLContext);
+  const auto& egl = gle->mEgl;
+  egl->fMakeCurrent(EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+}
+
+bool DMABufSurface::IsGlobalRefSet() const {
+  if (!mGlobalRefCountFd) {
+    return false;
+  }
+  struct pollfd pfd;
+  pfd.fd = mGlobalRefCountFd;
+  pfd.events = POLLIN;
+  return poll(&pfd, 1, 0) == 1;
+}
+
+void DMABufSurface::GlobalRefRelease() {
+  MOZ_ASSERT(mGlobalRefCountFd);
+  uint64_t counter;
+  if (read(mGlobalRefCountFd, &counter, sizeof(counter)) != sizeof(counter)) {
+    // EAGAIN means the refcount is already zero. It happens when we release
+    // last reference to the surface.
+    if (errno != EAGAIN) {
+      NS_WARNING(nsPrintfCString("Failed to unref dmabuf global ref count: %s",
+                                 strerror(errno))
+                     .get());
+    }
+  }
+}
+
+void DMABufSurface::GlobalRefAdd() {
+  MOZ_ASSERT(mGlobalRefCountFd);
+  uint64_t counter = 1;
+  if (write(mGlobalRefCountFd, &counter, sizeof(counter)) != sizeof(counter)) {
+    NS_WARNING(nsPrintfCString("Failed to ref dmabuf global ref count: %s",
+                               strerror(errno))
+                   .get());
+  }
+}
+
+void DMABufSurface::GlobalRefCountCreate() {
+  MOZ_ASSERT(!mGlobalRefCountFd);
+  mGlobalRefCountFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK | EFD_SEMAPHORE);
+  if (mGlobalRefCountFd < 0) {
+    NS_WARNING(nsPrintfCString("Failed to create dmabuf global ref count: %s",
+                               strerror(errno))
+                   .get());
+    mGlobalRefCountFd = 0;
+    return;
+  }
+}
+
+void DMABufSurface::GlobalRefCountImport(int aFd) {
+  MOZ_ASSERT(!mGlobalRefCountFd);
+  mGlobalRefCountFd = aFd;
+  MOZ_DIAGNOSTIC_ASSERT(IsGlobalRefSet(),
+                        "We're importing unreferenced surface!");
+}
+
+int DMABufSurface::GlobalRefCountExport() {
+  if (mGlobalRefCountFd) {
+    MOZ_DIAGNOSTIC_ASSERT(IsGlobalRefSet(),
+                          "We're exporting unreferenced surface!");
+    GlobalRefAdd();
+  }
+  return mGlobalRefCountFd;
+}
+
+void DMABufSurface::GlobalRefCountDelete() {
+  if (mGlobalRefCountFd) {
+    GlobalRefRelease();
+    close(mGlobalRefCountFd);
+    mGlobalRefCountFd = 0;
+  }
+}
+
+void DMABufSurface::ReleaseDMABuf() {
+  LOGDMABUF(("DMABufSurface::ReleaseDMABuf() UID %d", mUID));
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    Unmap(i);
+  }
+
+  MutexAutoLock lockFD(mSurfaceLock);
+  CloseFileDescriptors(lockFD, /* aForceClose */ true);
+
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    if (mGbmBufferObject[i]) {
+      nsGbmLib::Destroy(mGbmBufferObject[i]);
+      mGbmBufferObject[i] = nullptr;
+    }
+  }
+  mBufferPlaneCount = 0;
+}
+
+DMABufSurface::DMABufSurface(SurfaceType aSurfaceType)
+    : mSurfaceType(aSurfaceType),
+      mBufferPlaneCount(0),
+      mDrmFormats(),
+      mStrides(),
+      mOffsets(),
+      mGbmBufferObject(),
+      mMappedRegion(),
+      mMappedRegionStride(),
+      mSyncFd(-1),
+      mSync(0),
+      mGlobalRefCountFd(0),
+      mUID(gNewSurfaceUID++),
+      mSurfaceLock("DMABufSurface") {
+  for (auto& slot : mDmabufFds) {
+    slot = -1;
+  }
+  for (auto& modifier : mBufferModifiers) {
+    modifier = DRM_FORMAT_MOD_INVALID;
+  }
+}
+
+DMABufSurface::~DMABufSurface() {
+  FenceDelete();
+  GlobalRefCountDelete();
+}
+
+already_AddRefed<DMABufSurface> DMABufSurface::CreateDMABufSurface(
+    const mozilla::layers::SurfaceDescriptor& aDesc) {
+  const SurfaceDescriptorDMABuf& desc = aDesc.get_SurfaceDescriptorDMABuf();
+  RefPtr<DMABufSurface> surf;
+
+  switch (desc.bufferType()) {
+    case SURFACE_RGBA:
+      surf = new DMABufSurfaceRGBA();
+      break;
+    case SURFACE_NV12:
+    case SURFACE_YUV420:
+      surf = new DMABufSurfaceYUV();
+      break;
+    default:
+      return nullptr;
+  }
+
+  if (!surf->Create(desc)) {
+    return nullptr;
+  }
+  return surf.forget();
+}
+
+void DMABufSurface::FenceDelete() {
+  if (mSyncFd > 0) {
+    close(mSyncFd);
+    mSyncFd = -1;
+  }
+
+  if (!mGL) {
+    return;
+  }
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  if (mSync) {
+    egl->fDestroySync(mSync);
+    mSync = nullptr;
+  }
+}
+
+void DMABufSurface::FenceSet() {
+  if (!mGL || !mGL->MakeCurrent()) {
+    MOZ_DIAGNOSTIC_ASSERT(mGL,
+                          "DMABufSurface::FenceSet(): missing GL context!");
+    return;
+  }
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  if (egl->IsExtensionSupported(EGLExtension::KHR_fence_sync) &&
+      egl->IsExtensionSupported(EGLExtension::ANDROID_native_fence_sync)) {
+    FenceDelete();
+
+    mSync = egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
+    if (mSync) {
+      mSyncFd = egl->fDupNativeFenceFDANDROID(mSync);
+      mGL->fFlush();
+      return;
+    }
+  }
+
+  // ANDROID_native_fence_sync may not be supported so call glFinish()
+  // as a slow path.
+  mGL->fFinish();
+}
+
+void DMABufSurface::FenceWait() {
+  if (!mGL || mSyncFd < 0) {
+    MOZ_DIAGNOSTIC_ASSERT(mGL,
+                          "DMABufSurface::FenceWait() missing GL context!");
+    return;
+  }
+
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID, mSyncFd,
+                            LOCAL_EGL_NONE};
+  EGLSync sync = egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
+  if (!sync) {
+    MOZ_ASSERT(false, "DMABufSurface::FenceWait(): Failed to create GLFence!");
+    // We failed to create GLFence so clear mSyncFd to avoid another try.
+    close(mSyncFd);
+    mSyncFd = -1;
+    return;
+  }
+
+  // mSyncFd is owned by GLFence so clear local reference to avoid double close
+  // at DMABufSurface::FenceDelete().
+  mSyncFd = -1;
+
+  egl->fClientWaitSync(sync, 0, LOCAL_EGL_FOREVER);
+  egl->fDestroySync(sync);
+}
+
+bool DMABufSurface::OpenFileDescriptors(const MutexAutoLock& aProofOfLock) {
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    if (!OpenFileDescriptorForPlane(aProofOfLock, i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// We can safely close DMABuf file descriptors only when we have a valid
+// GbmBufferObject. When we don't have a valid GbmBufferObject and a DMABuf
+// file descriptor is closed, whole surface is released.
+void DMABufSurface::CloseFileDescriptors(const MutexAutoLock& aProofOfLock,
+                                         bool aForceClose) {
+  for (int i = 0; i < DMABUF_BUFFER_PLANES; i++) {
+    CloseFileDescriptorForPlane(aProofOfLock, i, aForceClose);
+  }
+}
+
+DMABufSurfaceRGBA::DMABufSurfaceRGBA()
+    : DMABufSurface(SURFACE_RGBA),
+      mSurfaceFlags(0),
+      mWidth(0),
+      mHeight(0),
+      mGmbFormat(nullptr),
+      mEGLImage(LOCAL_EGL_NO_IMAGE),
+      mTexture(0),
+      mGbmBufferFlags(0),
+      mWlBuffer(nullptr) {}
+
+DMABufSurfaceRGBA::~DMABufSurfaceRGBA() {
+  ReleaseWlBuffer();
+  ReleaseSurface();
+}
+
+bool DMABufSurfaceRGBA::OpenFileDescriptorForPlane(
+    const MutexAutoLock& aProofOfLock, int aPlane) {
+  if (mDmabufFds[aPlane] >= 0) {
+    return true;
+  }
+  gbm_bo* bo = mGbmBufferObject[0];
+  if (NS_WARN_IF(!bo)) {
+    LOGDMABUF(
+        ("DMABufSurfaceRGBA::OpenFileDescriptorForPlane: Missing "
+         "mGbmBufferObject object!"));
+    return false;
+  }
+
+  if (mBufferPlaneCount == 1) {
+    MOZ_ASSERT(aPlane == 0, "DMABuf: wrong surface plane!");
+    mDmabufFds[0] = nsGbmLib::GetFd(bo);
+  } else {
+    uint32_t handle = nsGbmLib::GetHandleForPlane(bo, aPlane).u32;
+    int ret = nsGbmLib::DrmPrimeHandleToFD(GetDMABufDevice()->GetDRMFd(),
+                                           handle, 0, &mDmabufFds[aPlane]);
+    if (ret < 0) {
+      mDmabufFds[aPlane] = -1;
+    }
+  }
+
+  if (mDmabufFds[aPlane] < 0) {
+    CloseFileDescriptors(aProofOfLock);
+    return false;
+  }
+
+  return true;
+}
+
+void DMABufSurfaceRGBA::CloseFileDescriptorForPlane(
+    const MutexAutoLock& aProofOfLock, int aPlane, bool aForceClose = false) {
+  if ((aForceClose || mGbmBufferObject[0]) && mDmabufFds[aPlane] >= 0) {
+    close(mDmabufFds[aPlane]);
+    mDmabufFds[aPlane] = -1;
+  }
+}
+
+bool DMABufSurfaceRGBA::Create(int aWidth, int aHeight,
+                               int aDMABufSurfaceFlags) {
+  MOZ_ASSERT(mGbmBufferObject[0] == nullptr, "Already created?");
+
+  mSurfaceFlags = aDMABufSurfaceFlags;
+  mWidth = aWidth;
+  mHeight = aHeight;
+
+  LOGDMABUF(("DMABufSurfaceRGBA::Create() UID %d size %d x %d\n", mUID, mWidth,
+             mHeight));
+
+  if (!GetDMABufDevice()->GetGbmDevice()) {
+    LOGDMABUF(("    Missing GbmDevice!"));
+    return false;
+  }
+
+  mGmbFormat = GetDMABufDevice()->GetGbmFormat(mSurfaceFlags & DMABUF_ALPHA);
+  if (!mGmbFormat) {
+    // Requested DRM format is not supported.
+    return false;
+  }
+  mDrmFormats[0] = mGmbFormat->mFormat;
+
+  bool useModifiers = (aDMABufSurfaceFlags & DMABUF_USE_MODIFIERS) &&
+                      mGmbFormat->mModifiersCount > 0;
+  if (useModifiers) {
+    LOGDMABUF(("    Creating with modifiers\n"));
+    mGbmBufferObject[0] = nsGbmLib::CreateWithModifiers(
+        GetDMABufDevice()->GetGbmDevice(), mWidth, mHeight, mDrmFormats[0],
+        mGmbFormat->mModifiers, mGmbFormat->mModifiersCount);
+    if (mGbmBufferObject[0]) {
+      mBufferModifiers[0] = nsGbmLib::GetModifier(mGbmBufferObject[0]);
+    }
+  }
+
+  if (!mGbmBufferObject[0]) {
+    LOGDMABUF(("    Creating without modifiers\n"));
+    mGbmBufferFlags = GBM_BO_USE_LINEAR;
+    mGbmBufferObject[0] =
+        nsGbmLib::Create(GetDMABufDevice()->GetGbmDevice(), mWidth, mHeight,
+                         mDrmFormats[0], mGbmBufferFlags);
+    mBufferModifiers[0] = DRM_FORMAT_MOD_INVALID;
+  }
+
+  if (!mGbmBufferObject[0]) {
+    LOGDMABUF(("    Failed to create GbmBufferObject\n"));
+    return false;
+  }
+
+  if (mBufferModifiers[0] != DRM_FORMAT_MOD_INVALID) {
+    mBufferPlaneCount = nsGbmLib::GetPlaneCount(mGbmBufferObject[0]);
+    if (mBufferPlaneCount > DMABUF_BUFFER_PLANES) {
+      LOGDMABUF(("    There's too many dmabuf planes!"));
+      ReleaseSurface();
+      return false;
+    }
+
+    for (int i = 0; i < mBufferPlaneCount; i++) {
+      mStrides[i] = nsGbmLib::GetStrideForPlane(mGbmBufferObject[0], i);
+      mOffsets[i] = nsGbmLib::GetOffset(mGbmBufferObject[0], i);
+    }
+  } else {
+    mBufferPlaneCount = 1;
+    mStrides[0] = nsGbmLib::GetStride(mGbmBufferObject[0]);
+  }
+
+  LOGDMABUF(("    Success\n"));
+  return true;
+}
+
+bool DMABufSurfaceRGBA::Create(mozilla::gl::GLContext* aGLContext,
+                               const EGLImageKHR aEGLImage, int aWidth,
+                               int aHeight) {
+  LOGDMABUF(("DMABufSurfaceRGBA::Create() from EGLImage UID = %d\n", mUID));
+  if (!aGLContext) {
+    return false;
+  }
+  const auto& gle = gl::GLContextEGL::Cast(aGLContext);
+  const auto& egl = gle->mEgl;
+
+  mGL = aGLContext;
+  mWidth = aWidth;
+  mHeight = aHeight;
+  mEGLImage = aEGLImage;
+  if (!egl->fExportDMABUFImageQuery(mEGLImage, mDrmFormats, &mBufferPlaneCount,
+                                    mBufferModifiers)) {
+    LOGDMABUF(("  ExportDMABUFImageQueryMESA failed, quit\n"));
+    return false;
+  }
+  if (mBufferPlaneCount > DMABUF_BUFFER_PLANES) {
+    LOGDMABUF(("  wrong plane count %d, quit\n", mBufferPlaneCount));
+    return false;
+  }
+  if (!egl->fExportDMABUFImage(mEGLImage, mDmabufFds, mStrides, mOffsets)) {
+    LOGDMABUF(("  ExportDMABUFImageMESA failed, quit\n"));
+    return false;
+  }
+
+  // A broken driver can return dmabuf without valid file descriptors
+  // which leads to fails later so quit now.
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    if (mDmabufFds[i] < 0) {
+      LOGDMABUF(
+          ("  ExportDMABUFImageMESA failed, mDmabufFds[%d] is invalid, quit",
+           i));
+      return false;
+    }
+  }
+
+  LOGDMABUF(("  imported size %d x %d format %x planes %d modifiers %" PRIx64,
+             mWidth, mHeight, mDrmFormats[0], mBufferPlaneCount,
+             mBufferModifiers[0]));
+  return true;
+}
+
+bool DMABufSurfaceRGBA::ImportSurfaceDescriptor(
+    const SurfaceDescriptor& aDesc) {
+  const SurfaceDescriptorDMABuf& desc = aDesc.get_SurfaceDescriptorDMABuf();
+
+  mWidth = desc.width()[0];
+  mHeight = desc.height()[0];
+  mBufferModifiers[0] = desc.modifier()[0];
+  mDrmFormats[0] = desc.format()[0];
+  mBufferPlaneCount = desc.fds().Length();
+  mGbmBufferFlags = desc.flags();
+  MOZ_RELEASE_ASSERT(mBufferPlaneCount <= DMABUF_BUFFER_PLANES);
+  mUID = desc.uid();
+
+  LOGDMABUF(
+      ("DMABufSurfaceRGBA::ImportSurfaceDescriptor() UID %d size %d x %d\n",
+       mUID, mWidth, mHeight));
+
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    mDmabufFds[i] = desc.fds()[i].ClonePlatformHandle().release();
+    if (mDmabufFds[i] < 0) {
+      LOGDMABUF(
+          ("    failed to get DMABuf file descriptor: %s", strerror(errno)));
+      return false;
+    }
+    mStrides[i] = desc.strides()[i];
+    mOffsets[i] = desc.offsets()[i];
+  }
+
+  if (desc.fence().Length() > 0) {
+    mSyncFd = desc.fence()[0].ClonePlatformHandle().release();
+    if (mSyncFd < 0) {
+      LOGDMABUF(
+          ("    failed to get GL fence file descriptor: %s", strerror(errno)));
+      return false;
+    }
+  }
+
+  if (desc.refCount().Length() > 0) {
+    GlobalRefCountImport(desc.refCount()[0].ClonePlatformHandle().release());
+  }
+
+  LOGDMABUF(("  imported size %d x %d format %x planes %d", mWidth, mHeight,
+             mDrmFormats[0], mBufferPlaneCount));
+  return true;
+}
+
+bool DMABufSurfaceRGBA::Create(const SurfaceDescriptor& aDesc) {
+  return ImportSurfaceDescriptor(aDesc);
+}
+
+bool DMABufSurfaceRGBA::Serialize(
+    mozilla::layers::SurfaceDescriptor& aOutDescriptor) {
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> width;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> height;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> format;
+  AutoTArray<ipc::FileDescriptor, DMABUF_BUFFER_PLANES> fds;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> strides;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> offsets;
+  AutoTArray<uintptr_t, DMABUF_BUFFER_PLANES> images;
+  AutoTArray<uint64_t, DMABUF_BUFFER_PLANES> modifiers;
+  AutoTArray<ipc::FileDescriptor, 1> fenceFDs;
+  AutoTArray<ipc::FileDescriptor, 1> refCountFDs;
+
+  LOGDMABUF(("DMABufSurfaceRGBA::Serialize() UID %d\n", mUID));
+
+  MutexAutoLock lockFD(mSurfaceLock);
+  if (!OpenFileDescriptors(lockFD)) {
+    return false;
+  }
+
+  width.AppendElement(mWidth);
+  height.AppendElement(mHeight);
+  format.AppendElement(mDrmFormats[0]);
+  modifiers.AppendElement(mBufferModifiers[0]);
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    fds.AppendElement(ipc::FileDescriptor(mDmabufFds[i]));
+    strides.AppendElement(mStrides[i]);
+    offsets.AppendElement(mOffsets[i]);
+  }
+
+  CloseFileDescriptors(lockFD);
+
+  if (mSync) {
+    fenceFDs.AppendElement(ipc::FileDescriptor(mSyncFd));
+  }
+
+  if (mGlobalRefCountFd) {
+    refCountFDs.AppendElement(ipc::FileDescriptor(GlobalRefCountExport()));
+  }
+
+  aOutDescriptor = SurfaceDescriptorDMABuf(
+      mSurfaceType, modifiers, mGbmBufferFlags, fds, width, height, width,
+      height, format, strides, offsets, GetYUVColorSpace(), mColorRange,
+      fenceFDs, mUID, refCountFDs);
+  return true;
+}
+
+bool DMABufSurfaceRGBA::CreateTexture(GLContext* aGLContext, int aPlane) {
+  LOGDMABUF(("DMABufSurfaceRGBA::CreateTexture() UID %d\n", mUID));
+  MOZ_ASSERT(!mEGLImage && !mTexture, "EGLImage is already created!");
+
+  nsTArray<EGLint> attribs;
+  attribs.AppendElement(LOCAL_EGL_WIDTH);
+  attribs.AppendElement(mWidth);
+  attribs.AppendElement(LOCAL_EGL_HEIGHT);
+  attribs.AppendElement(mHeight);
+  attribs.AppendElement(LOCAL_EGL_LINUX_DRM_FOURCC_EXT);
+  attribs.AppendElement(mDrmFormats[0]);
+#define ADD_PLANE_ATTRIBS(plane_idx)                                        \
+  {                                                                         \
+    attribs.AppendElement(LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_FD_EXT);     \
+    attribs.AppendElement(mDmabufFds[plane_idx]);                           \
+    attribs.AppendElement(LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_OFFSET_EXT); \
+    attribs.AppendElement((int)mOffsets[plane_idx]);                        \
+    attribs.AppendElement(LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_PITCH_EXT);  \
+    attribs.AppendElement((int)mStrides[plane_idx]);                        \
+    if (mBufferModifiers[0] != DRM_FORMAT_MOD_INVALID) {                    \
+      attribs.AppendElement(                                                \
+          LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_MODIFIER_LO_EXT);            \
+      attribs.AppendElement(mBufferModifiers[0] & 0xFFFFFFFF);              \
+      attribs.AppendElement(                                                \
+          LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_MODIFIER_HI_EXT);            \
+      attribs.AppendElement(mBufferModifiers[0] >> 32);                     \
+    }                                                                       \
+  }
+
+  MutexAutoLock lockFD(mSurfaceLock);
+  if (!OpenFileDescriptors(lockFD)) {
+    return false;
+  }
+  ADD_PLANE_ATTRIBS(0);
+  if (mBufferPlaneCount > 1) ADD_PLANE_ATTRIBS(1);
+  if (mBufferPlaneCount > 2) ADD_PLANE_ATTRIBS(2);
+  if (mBufferPlaneCount > 3) ADD_PLANE_ATTRIBS(3);
+#undef ADD_PLANE_ATTRIBS
+  attribs.AppendElement(LOCAL_EGL_NONE);
+
+  if (!aGLContext) return false;
+  const auto& gle = gl::GLContextEGL::Cast(aGLContext);
+  const auto& egl = gle->mEgl;
+  mEGLImage =
+      egl->fCreateImage(LOCAL_EGL_NO_CONTEXT, LOCAL_EGL_LINUX_DMA_BUF_EXT,
+                        nullptr, attribs.Elements());
+
+  CloseFileDescriptors(lockFD);
+
+  if (mEGLImage == LOCAL_EGL_NO_IMAGE) {
+    LOGDMABUF(("EGLImageKHR creation failed"));
+    return false;
+  }
+
+  if (!aGLContext->MakeCurrent()) {
+    LOGDMABUF(
+        ("DMABufSurfaceRGBA::CreateTexture(): failed to make GL context "
+         "current"));
+    return false;
+  }
+  aGLContext->fGenTextures(1, &mTexture);
+  const ScopedBindTexture savedTex(aGLContext, mTexture);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_S,
+                             LOCAL_GL_CLAMP_TO_EDGE);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_T,
+                             LOCAL_GL_CLAMP_TO_EDGE);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER,
+                             LOCAL_GL_LINEAR);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER,
+                             LOCAL_GL_LINEAR);
+  aGLContext->fEGLImageTargetTexture2D(LOCAL_GL_TEXTURE_2D, mEGLImage);
+  mGL = aGLContext;
+
+  return true;
+}
+
+void DMABufSurfaceRGBA::ReleaseTextures() {
+  LOGDMABUF(("DMABufSurfaceRGBA::ReleaseTextures() UID %d\n", mUID));
+  FenceDelete();
+
+  if (!mTexture && !mEGLImage) {
+    return;
+  }
+
+  if (!mGL) {
+#ifdef NIGHTLY_BUILD
+    MOZ_DIAGNOSTIC_ASSERT(mGL, "Missing GL context!");
+#else
+    NS_WARNING(
+        "DMABufSurfaceRGBA::ReleaseTextures(): Missing GL context! We're "
+        "leaking textures!");
+    return;
+#endif
+  }
+
+  const auto& gle = gl::GLContextEGL::Cast(mGL);
+  const auto& egl = gle->mEgl;
+
+  if (mTexture && mGL->MakeCurrent()) {
+    mGL->fDeleteTextures(1, &mTexture);
+    mTexture = 0;
+  }
+
+  if (mEGLImage != LOCAL_EGL_NO_IMAGE) {
+    egl->fDestroyImage(mEGLImage);
+    mEGLImage = LOCAL_EGL_NO_IMAGE;
+  }
+  mGL = nullptr;
+}
+
+void DMABufSurfaceRGBA::ReleaseSurface() {
+  MOZ_ASSERT(!IsMapped(), "We can't release mapped buffer!");
+
+  ReleaseTextures();
+  ReleaseDMABuf();
+}
+
+bool DMABufSurfaceRGBA::CreateWlBuffer() {
+  MutexAutoLock lockFD(mSurfaceLock);
+  if (!OpenFileDescriptors(lockFD)) {
+    return false;
+  }
+
+  RefPtr<nsWaylandDisplay> waylandDisplay = widget::WaylandDisplayGet();
+  if (!waylandDisplay->GetDmabuf()) {
+    CloseFileDescriptors(lockFD);
+    return false;
+  }
+
+  struct zwp_linux_buffer_params_v1* params =
+      zwp_linux_dmabuf_v1_create_params(waylandDisplay->GetDmabuf());
+  zwp_linux_buffer_params_v1_add(params, mDmabufFds[0], 0, mOffsets[0],
+                                 mStrides[0], mBufferModifiers[0] >> 32,
+                                 mBufferModifiers[0] & 0xffffffff);
+
+  mWlBuffer = zwp_linux_buffer_params_v1_create_immed(
+      params, GetWidth(), GetHeight(), mDrmFormats[0], 0);
+
+  CloseFileDescriptors(lockFD);
+
+  return mWlBuffer != nullptr;
+}
+
+void DMABufSurfaceRGBA::ReleaseWlBuffer() {
+  MozClearPointer(mWlBuffer, wl_buffer_destroy);
+}
+
+// We should synchronize DMA Buffer object access from CPU to avoid potential
+// cache incoherency and data loss.
+// See
+// https://01.org/linuxgraphics/gfx-docs/drm/driver-api/dma-buf.html#cpu-access-to-dma-buffer-objects
+struct dma_buf_sync {
+  uint64_t flags;
+};
+#define DMA_BUF_SYNC_READ (1 << 0)
+#define DMA_BUF_SYNC_WRITE (2 << 0)
+#define DMA_BUF_SYNC_START (0 << 2)
+#define DMA_BUF_SYNC_END (1 << 2)
+#define DMA_BUF_BASE 'b'
+#define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
+
+static void SyncDmaBuf(int aFd, uint64_t aFlags) {
+  struct dma_buf_sync sync = {0};
+
+  sync.flags = aFlags | DMA_BUF_SYNC_READ | DMA_BUF_SYNC_WRITE;
+  while (true) {
+    int ret;
+    ret = ioctl(aFd, DMA_BUF_IOCTL_SYNC, &sync);
+    if (ret == -1 && errno == EINTR) {
+      continue;
+    } else if (ret == -1) {
+      LOGDMABUF(
+          ("Failed to synchronize DMA buffer: %s FD %d", strerror(errno), aFd));
+      break;
+    } else {
+      break;
+    }
+  }
+}
+
+void* DMABufSurface::MapInternal(uint32_t aX, uint32_t aY, uint32_t aWidth,
+                                 uint32_t aHeight, uint32_t* aStride,
+                                 int aGbmFlags, int aPlane) {
+  NS_ASSERTION(!IsMapped(aPlane), "Already mapped!");
+  if (!mGbmBufferObject[aPlane]) {
+    NS_WARNING("We can't map DMABufSurfaceRGBA without mGbmBufferObject");
+    return nullptr;
+  }
+
+  LOGDMABUF(
+      ("DMABufSurfaceRGBA::MapInternal() UID %d plane %d size %d x %d -> %d x "
+       "%d\n",
+       mUID, aPlane, aX, aY, aWidth, aHeight));
+
+  mMappedRegionStride[aPlane] = 0;
+  mMappedRegionData[aPlane] = nullptr;
+  mMappedRegion[aPlane] = nsGbmLib::Map(
+      mGbmBufferObject[aPlane], aX, aY, aWidth, aHeight, aGbmFlags,
+      &mMappedRegionStride[aPlane], &mMappedRegionData[aPlane]);
+  if (!mMappedRegion[aPlane]) {
+    LOGDMABUF(("    Surface mapping failed: %s", strerror(errno)));
+    return nullptr;
+  }
+  if (aStride) {
+    *aStride = mMappedRegionStride[aPlane];
+  }
+
+  MutexAutoLock lockFD(mSurfaceLock);
+  if (OpenFileDescriptorForPlane(lockFD, aPlane)) {
+    SyncDmaBuf(mDmabufFds[aPlane], DMA_BUF_SYNC_START);
+    CloseFileDescriptorForPlane(lockFD, aPlane);
+  }
+
+  return mMappedRegion[aPlane];
+}
+
+void* DMABufSurfaceRGBA::MapReadOnly(uint32_t aX, uint32_t aY, uint32_t aWidth,
+                                     uint32_t aHeight, uint32_t* aStride) {
+  return MapInternal(aX, aY, aWidth, aHeight, aStride, GBM_BO_TRANSFER_READ);
+}
+
+void* DMABufSurfaceRGBA::MapReadOnly(uint32_t* aStride) {
+  return MapInternal(0, 0, mWidth, mHeight, aStride, GBM_BO_TRANSFER_READ);
+}
+
+void* DMABufSurfaceRGBA::Map(uint32_t aX, uint32_t aY, uint32_t aWidth,
+                             uint32_t aHeight, uint32_t* aStride) {
+  return MapInternal(aX, aY, aWidth, aHeight, aStride,
+                     GBM_BO_TRANSFER_READ_WRITE);
+}
+
+void* DMABufSurfaceRGBA::Map(uint32_t* aStride) {
+  return MapInternal(0, 0, mWidth, mHeight, aStride,
+                     GBM_BO_TRANSFER_READ_WRITE);
+}
+
+void DMABufSurface::Unmap(int aPlane) {
+  if (mMappedRegion[aPlane]) {
+    LOGDMABUF(("DMABufSurface::Unmap() UID %d plane %d\n", mUID, aPlane));
+    MutexAutoLock lockFD(mSurfaceLock);
+    if (OpenFileDescriptorForPlane(lockFD, aPlane)) {
+      SyncDmaBuf(mDmabufFds[aPlane], DMA_BUF_SYNC_END);
+      CloseFileDescriptorForPlane(lockFD, aPlane);
+    }
+    nsGbmLib::Unmap(mGbmBufferObject[aPlane], mMappedRegionData[aPlane]);
+    mMappedRegion[aPlane] = nullptr;
+    mMappedRegionData[aPlane] = nullptr;
+    mMappedRegionStride[aPlane] = 0;
+  }
+}
+
+#ifdef DEBUG
+void DMABufSurfaceRGBA::DumpToFile(const char* pFile) {
+  uint32_t stride;
+
+  if (!MapReadOnly(&stride)) {
+    return;
+  }
+  cairo_surface_t* surface = nullptr;
+
+  auto unmap = MakeScopeExit([&] {
+    if (surface) {
+      cairo_surface_destroy(surface);
+    }
+    Unmap();
+  });
+
+  surface = cairo_image_surface_create_for_data(
+      (unsigned char*)mMappedRegion[0], CAIRO_FORMAT_ARGB32, mWidth, mHeight,
+      stride);
+  if (cairo_surface_status(surface) == CAIRO_STATUS_SUCCESS) {
+    cairo_surface_write_to_png(surface, pFile);
+  }
+}
+#endif
+
+#if 0
+// Copy from source surface by GL
+#  include "GLBlitHelper.h"
+
+bool DMABufSurfaceRGBA::CopyFrom(class DMABufSurface* aSourceSurface,
+                                 GLContext* aGLContext) {
+  MOZ_ASSERT(aSourceSurface->GetTexture());
+  MOZ_ASSERT(GetTexture());
+
+  gfx::IntSize size(GetWidth(), GetHeight());
+  aGLContext->BlitHelper()->BlitTextureToTexture(aSourceSurface->GetTexture(),
+    GetTexture(), size, size);
+  return true;
+}
+#endif
+
+// TODO - Clear the surface by EGL
+void DMABufSurfaceRGBA::Clear() {
+  uint32_t destStride;
+  void* destData = Map(&destStride);
+  memset(destData, 0, GetHeight() * destStride);
+  Unmap();
+}
+
+bool DMABufSurfaceRGBA::HasAlpha() {
+  return !mGmbFormat || mGmbFormat->mHasAlpha;
+}
+
+gfx::SurfaceFormat DMABufSurfaceRGBA::GetFormat() {
+  return HasAlpha() ? gfx::SurfaceFormat::B8G8R8A8
+                    : gfx::SurfaceFormat::B8G8R8X8;
+}
+
+// GL uses swapped R and B components so report accordingly.
+gfx::SurfaceFormat DMABufSurfaceRGBA::GetFormatGL() {
+  return HasAlpha() ? gfx::SurfaceFormat::R8G8B8A8
+                    : gfx::SurfaceFormat::R8G8B8X8;
+}
+
+already_AddRefed<DMABufSurfaceRGBA> DMABufSurfaceRGBA::CreateDMABufSurface(
+    int aWidth, int aHeight, int aDMABufSurfaceFlags) {
+  RefPtr<DMABufSurfaceRGBA> surf = new DMABufSurfaceRGBA();
+  if (!surf->Create(aWidth, aHeight, aDMABufSurfaceFlags)) {
+    return nullptr;
+  }
+  return surf.forget();
+}
+
+already_AddRefed<DMABufSurface> DMABufSurfaceRGBA::CreateDMABufSurface(
+    mozilla::gl::GLContext* aGLContext, const EGLImageKHR aEGLImage, int aWidth,
+    int aHeight) {
+  RefPtr<DMABufSurfaceRGBA> surf = new DMABufSurfaceRGBA();
+  if (!surf->Create(aGLContext, aEGLImage, aWidth, aHeight)) {
+    return nullptr;
+  }
+  return surf.forget();
+}
+
+already_AddRefed<DMABufSurfaceYUV> DMABufSurfaceYUV::CreateYUVSurface(
+    const VADRMPRIMESurfaceDescriptor& aDesc, int aWidth, int aHeight) {
+  RefPtr<DMABufSurfaceYUV> surf = new DMABufSurfaceYUV();
+  LOGDMABUF(("DMABufSurfaceYUV::CreateYUVSurface() UID %d from desc\n",
+             surf->GetUID()));
+  if (!surf->UpdateYUVData(aDesc, aWidth, aHeight)) {
+    return nullptr;
+  }
+  return surf.forget();
+}
+
+already_AddRefed<DMABufSurfaceYUV> DMABufSurfaceYUV::CreateYUVSurface(
+    int aWidth, int aHeight, void** aPixelData, int* aLineSizes) {
+  RefPtr<DMABufSurfaceYUV> surf = new DMABufSurfaceYUV();
+  LOGDMABUF(("DMABufSurfaceYUV::CreateYUVSurface() UID %d %d x %d\n",
+             surf->GetUID(), aWidth, aHeight));
+  if (!surf->Create(aWidth, aHeight, aPixelData, aLineSizes)) {
+    return nullptr;
+  }
+  return surf.forget();
+}
+
+DMABufSurfaceYUV::DMABufSurfaceYUV()
+    : DMABufSurface(SURFACE_NV12),
+      mWidth(),
+      mHeight(),
+      mWidthAligned(),
+      mHeightAligned(),
+      mTexture() {
+  for (int i = 0; i < DMABUF_BUFFER_PLANES; i++) {
+    mEGLImage[i] = LOCAL_EGL_NO_IMAGE;
+  }
+}
+
+DMABufSurfaceYUV::~DMABufSurfaceYUV() { ReleaseSurface(); }
+
+bool DMABufSurfaceYUV::OpenFileDescriptorForPlane(
+    const MutexAutoLock& aProofOfLock, int aPlane) {
+  // The fd is already opened, no need to reopen.
+  // This can happen when we import dmabuf surface from VA-API decoder,
+  // mGbmBufferObject is null and we don't close
+  // file descriptors for surface as they are our only reference to it.
+  if (mDmabufFds[aPlane] >= 0) {
+    return true;
+  }
+
+  if (mGbmBufferObject[aPlane] == nullptr) {
+    LOGDMABUF(
+        ("DMABufSurfaceYUV::OpenFileDescriptorForPlane: Missing "
+         "mGbmBufferObject object!"));
+    return false;
+  }
+
+  mDmabufFds[aPlane] = nsGbmLib::GetFd(mGbmBufferObject[aPlane]);
+  if (mDmabufFds[aPlane] < 0) {
+    CloseFileDescriptors(aProofOfLock);
+    return false;
+  }
+  return true;
+}
+
+void DMABufSurfaceYUV::CloseFileDescriptorForPlane(
+    const MutexAutoLock& aProofOfLock, int aPlane, bool aForceClose = false) {
+  if ((aForceClose || mGbmBufferObject[aPlane]) && mDmabufFds[aPlane] >= 0) {
+    close(mDmabufFds[aPlane]);
+    mDmabufFds[aPlane] = -1;
+  }
+}
+
+bool DMABufSurfaceYUV::UpdateYUVData(const VADRMPRIMESurfaceDescriptor& aDesc,
+                                     int aWidth, int aHeight) {
+  if (aDesc.num_layers > DMABUF_BUFFER_PLANES ||
+      aDesc.num_objects > DMABUF_BUFFER_PLANES) {
+    return false;
+  }
+
+  LOGDMABUF(("DMABufSurfaceYUV::UpdateYUVData() UID %d", mUID));
+  if (mDmabufFds[0] >= 0) {
+    LOGDMABUF(("    Already created!"));
+    return false;
+  }
+  if (aDesc.fourcc == VA_FOURCC_NV12) {
+    mSurfaceType = SURFACE_NV12;
+  } else if (aDesc.fourcc == VA_FOURCC_P010) {
+    mSurfaceType = SURFACE_NV12;
+  } else if (aDesc.fourcc == VA_FOURCC_YV12) {
+    mSurfaceType = SURFACE_YUV420;
+  } else {
+    LOGDMABUF(("UpdateYUVData(): Can't import surface data of 0x%x format",
+               aDesc.fourcc));
+    return false;
+  }
+
+  mBufferPlaneCount = aDesc.num_layers;
+
+  for (unsigned int i = 0; i < aDesc.num_layers; i++) {
+    unsigned int object = aDesc.layers[i].object_index[0];
+    // Intel exports VA-API surfaces in one object,planes have the same FD.
+    // AMD exports surfaces in two objects with different FDs.
+    int fd = aDesc.objects[object].fd;
+    bool dupFD = (object != i);
+    mDmabufFds[i] = dupFD ? dup(fd) : fd;
+
+    mBufferModifiers[i] = aDesc.objects[object].drm_format_modifier;
+    mDrmFormats[i] = aDesc.layers[i].drm_format;
+    mOffsets[i] = aDesc.layers[i].offset[0];
+    mStrides[i] = aDesc.layers[i].pitch[0];
+    mWidthAligned[i] = aDesc.width >> i;
+    mHeightAligned[i] = aDesc.height >> i;
+    mWidth[i] = aWidth >> i;
+    mHeight[i] = aHeight >> i;
+
+    LOGDMABUF(("    plane %d size %d x %d format %x", i, mWidth[i], mHeight[i],
+               mDrmFormats[i]));
+  }
+
+  return true;
+}
+
+bool DMABufSurfaceYUV::CreateYUVPlane(int aPlane, int aWidth, int aHeight,
+                                      int aDrmFormat) {
+  LOGDMABUF(("DMABufSurfaceYUV::CreateYUVPlane() UID %d size %d x %d", mUID,
+             aWidth, aHeight));
+
+  if (!GetDMABufDevice()->GetGbmDevice()) {
+    LOGDMABUF(("    Missing GbmDevice!"));
+    return false;
+  }
+
+  mWidth[aPlane] = aWidth;
+  mHeight[aPlane] = aHeight;
+  mDrmFormats[aPlane] = aDrmFormat;
+
+  mGbmBufferObject[aPlane] =
+      nsGbmLib::Create(GetDMABufDevice()->GetGbmDevice(), aWidth, aHeight,
+                       aDrmFormat, GBM_BO_USE_LINEAR);
+  if (!mGbmBufferObject[aPlane]) {
+    LOGDMABUF(("    Failed to create GbmBufferObject: %s", strerror(errno)));
+    return false;
+  }
+
+  mStrides[aPlane] = nsGbmLib::GetStride(mGbmBufferObject[aPlane]);
+  mDmabufFds[aPlane] = -1;
+
+  return true;
+}
+
+void DMABufSurfaceYUV::UpdateYUVPlane(int aPlane, void* aPixelData,
+                                      int aLineSize) {
+  LOGDMABUF(
+      ("DMABufSurfaceYUV::UpdateYUVPlane() UID %d plane %d", mUID, aPlane));
+  if (aLineSize == mWidth[aPlane] &&
+      (int)mMappedRegionStride[aPlane] == mWidth[aPlane]) {
+    memcpy(mMappedRegion[aPlane], aPixelData, aLineSize * mHeight[aPlane]);
+  } else {
+    char* src = (char*)aPixelData;
+    char* dest = (char*)mMappedRegion[aPlane];
+    for (int i = 0; i < mHeight[aPlane]; i++) {
+      memcpy(dest, src, mWidth[aPlane]);
+      src += aLineSize;
+      dest += mMappedRegionStride[aPlane];
+    }
+  }
+}
+
+bool DMABufSurfaceYUV::UpdateYUVData(void** aPixelData, int* aLineSizes) {
+  LOGDMABUF(("DMABufSurfaceYUV::UpdateYUVData() UID %d", mUID));
+  if (mSurfaceType != SURFACE_YUV420) {
+    LOGDMABUF(("    UpdateYUVData can upload YUV420 surface type only!"));
+    return false;
+  }
+
+  if (mBufferPlaneCount != 3) {
+    LOGDMABUF(("    DMABufSurfaceYUV planes does not match!"));
+    return false;
+  }
+
+  auto unmapBuffers = MakeScopeExit([&] {
+    Unmap(0);
+    Unmap(1);
+    Unmap(2);
+  });
+
+  // Map planes
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    MapInternal(0, 0, mWidth[i], mHeight[i], nullptr, GBM_BO_TRANSFER_WRITE, i);
+    if (!mMappedRegion[i]) {
+      LOGDMABUF(("    DMABufSurfaceYUV plane can't be mapped!"));
+      return false;
+    }
+    if ((int)mMappedRegionStride[i] < mWidth[i]) {
+      LOGDMABUF(("    DMABufSurfaceYUV plane size stride does not match!"));
+      return false;
+    }
+  }
+
+  // Copy planes
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    UpdateYUVPlane(i, aPixelData[i], aLineSizes[i]);
+  }
+
+  return true;
+}
+
+bool DMABufSurfaceYUV::Create(int aWidth, int aHeight, void** aPixelData,
+                              int* aLineSizes) {
+  LOGDMABUF(("DMABufSurfaceYUV::Create() UID %d size %d x %d", mUID, aWidth,
+             aHeight));
+
+  mSurfaceType = SURFACE_YUV420;
+  mBufferPlaneCount = 3;
+
+  if (!CreateYUVPlane(0, aWidth, aHeight, GBM_FORMAT_R8)) {
+    return false;
+  }
+  if (!CreateYUVPlane(1, aWidth >> 1, aHeight >> 1, GBM_FORMAT_R8)) {
+    return false;
+  }
+  if (!CreateYUVPlane(2, aWidth >> 1, aHeight >> 1, GBM_FORMAT_R8)) {
+    return false;
+  }
+  if (!aPixelData || !aLineSizes) {
+    return true;
+  }
+  return UpdateYUVData(aPixelData, aLineSizes);
+}
+
+bool DMABufSurfaceYUV::Create(const SurfaceDescriptor& aDesc) {
+  return ImportSurfaceDescriptor(aDesc);
+}
+
+bool DMABufSurfaceYUV::ImportSurfaceDescriptor(
+    const SurfaceDescriptorDMABuf& aDesc) {
+  mBufferPlaneCount = aDesc.fds().Length();
+  mSurfaceType = (mBufferPlaneCount == 2) ? SURFACE_NV12 : SURFACE_YUV420;
+  mColorSpace = aDesc.yUVColorSpace();
+  mColorRange = aDesc.colorRange();
+  mUID = aDesc.uid();
+
+  LOGDMABUF(("DMABufSurfaceYUV::ImportSurfaceDescriptor() UID %d", mUID));
+
+  MOZ_RELEASE_ASSERT(mBufferPlaneCount <= DMABUF_BUFFER_PLANES);
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    mDmabufFds[i] = aDesc.fds()[i].ClonePlatformHandle().release();
+    if (mDmabufFds[i] < 0) {
+      LOGDMABUF(("    failed to get DMABuf plane file descriptor: %s",
+                 strerror(errno)));
+      return false;
+    }
+    mWidth[i] = aDesc.width()[i];
+    mHeight[i] = aDesc.height()[i];
+    mWidthAligned[i] = aDesc.widthAligned()[i];
+    mHeightAligned[i] = aDesc.heightAligned()[i];
+    mDrmFormats[i] = aDesc.format()[i];
+    mStrides[i] = aDesc.strides()[i];
+    mOffsets[i] = aDesc.offsets()[i];
+    mBufferModifiers[i] = aDesc.modifier()[i];
+    LOGDMABUF(("    plane %d fd %d size %d x %d format %x", i, mDmabufFds[i],
+               mWidth[i], mHeight[i], mDrmFormats[i]));
+  }
+
+  if (aDesc.fence().Length() > 0) {
+    mSyncFd = aDesc.fence()[0].ClonePlatformHandle().release();
+    if (mSyncFd < 0) {
+      LOGDMABUF(
+          ("    failed to get GL fence file descriptor: %s", strerror(errno)));
+      return false;
+    }
+  }
+
+  if (aDesc.refCount().Length() > 0) {
+    GlobalRefCountImport(aDesc.refCount()[0].ClonePlatformHandle().release());
+  }
+
+  return true;
+}
+
+bool DMABufSurfaceYUV::Serialize(
+    mozilla::layers::SurfaceDescriptor& aOutDescriptor) {
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> width;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> height;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> widthBytes;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> heightBytes;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> format;
+  AutoTArray<ipc::FileDescriptor, DMABUF_BUFFER_PLANES> fds;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> strides;
+  AutoTArray<uint32_t, DMABUF_BUFFER_PLANES> offsets;
+  AutoTArray<uint64_t, DMABUF_BUFFER_PLANES> modifiers;
+  AutoTArray<ipc::FileDescriptor, 1> fenceFDs;
+  AutoTArray<ipc::FileDescriptor, 1> refCountFDs;
+
+  LOGDMABUF(("DMABufSurfaceYUV::Serialize() UID %d", mUID));
+
+  MutexAutoLock lockFD(mSurfaceLock);
+  if (!OpenFileDescriptors(lockFD)) {
+    return false;
+  }
+
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    width.AppendElement(mWidth[i]);
+    height.AppendElement(mHeight[i]);
+    widthBytes.AppendElement(mWidthAligned[i]);
+    heightBytes.AppendElement(mHeightAligned[i]);
+    format.AppendElement(mDrmFormats[i]);
+    fds.AppendElement(ipc::FileDescriptor(mDmabufFds[i]));
+    strides.AppendElement(mStrides[i]);
+    offsets.AppendElement(mOffsets[i]);
+    modifiers.AppendElement(mBufferModifiers[i]);
+  }
+
+  CloseFileDescriptors(lockFD);
+
+  if (mSync) {
+    fenceFDs.AppendElement(ipc::FileDescriptor(mSyncFd));
+  }
+
+  if (mGlobalRefCountFd) {
+    refCountFDs.AppendElement(ipc::FileDescriptor(GlobalRefCountExport()));
+  }
+
+  aOutDescriptor = SurfaceDescriptorDMABuf(
+      mSurfaceType, modifiers, 0, fds, width, height, widthBytes, heightBytes,
+      format, strides, offsets, GetYUVColorSpace(), mColorRange, fenceFDs, mUID,
+      refCountFDs);
+  return true;
+}
+
+bool DMABufSurfaceYUV::CreateEGLImage(GLContext* aGLContext, int aPlane) {
+  LOGDMABUF(
+      ("DMABufSurfaceYUV::CreateEGLImage() UID %d plane %d", mUID, aPlane));
+  MOZ_ASSERT(mEGLImage[aPlane] == LOCAL_EGL_NO_IMAGE,
+             "EGLImage is already created!");
+  MOZ_ASSERT(aGLContext, "Missing GLContext!");
+
+  const auto& gle = gl::GLContextEGL::Cast(aGLContext);
+  const auto& egl = gle->mEgl;
+
+  MutexAutoLock lockFD(mSurfaceLock);
+  if (!OpenFileDescriptorForPlane(lockFD, aPlane)) {
+    LOGDMABUF(("  failed to open dmabuf file descriptors"));
+    return false;
+  }
+
+  nsTArray<EGLint> attribs;
+  attribs.AppendElement(LOCAL_EGL_WIDTH);
+  attribs.AppendElement(mWidthAligned[aPlane]);
+  attribs.AppendElement(LOCAL_EGL_HEIGHT);
+  attribs.AppendElement(mHeightAligned[aPlane]);
+  attribs.AppendElement(LOCAL_EGL_LINUX_DRM_FOURCC_EXT);
+  attribs.AppendElement(mDrmFormats[aPlane]);
+#define ADD_PLANE_ATTRIBS_NV12(plane_idx)                                 \
+  attribs.AppendElement(LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_FD_EXT);     \
+  attribs.AppendElement(mDmabufFds[aPlane]);                              \
+  attribs.AppendElement(LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_OFFSET_EXT); \
+  attribs.AppendElement((int)mOffsets[aPlane]);                           \
+  attribs.AppendElement(LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_PITCH_EXT);  \
+  attribs.AppendElement((int)mStrides[aPlane]);                           \
+  if (mBufferModifiers[aPlane] != DRM_FORMAT_MOD_INVALID) {               \
+    attribs.AppendElement(                                                \
+        LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_MODIFIER_LO_EXT);            \
+    attribs.AppendElement(mBufferModifiers[aPlane] & 0xFFFFFFFF);         \
+    attribs.AppendElement(                                                \
+        LOCAL_EGL_DMA_BUF_PLANE##plane_idx##_MODIFIER_HI_EXT);            \
+    attribs.AppendElement(mBufferModifiers[aPlane] >> 32);                \
+  }
+  ADD_PLANE_ATTRIBS_NV12(0);
+#undef ADD_PLANE_ATTRIBS_NV12
+  attribs.AppendElement(LOCAL_EGL_NONE);
+
+  mEGLImage[aPlane] =
+      egl->fCreateImage(LOCAL_EGL_NO_CONTEXT, LOCAL_EGL_LINUX_DMA_BUF_EXT,
+                        nullptr, attribs.Elements());
+
+  CloseFileDescriptorForPlane(lockFD, aPlane);
+
+  if (mEGLImage[aPlane] == LOCAL_EGL_NO_IMAGE) {
+    LOGDMABUF(("  EGLImageKHR creation failed"));
+    return false;
+  }
+
+  LOGDMABUF(("  Success."));
+  return true;
+}
+
+void DMABufSurfaceYUV::ReleaseEGLImages(GLContext* aGLContext) {
+  LOGDMABUF(("DMABufSurfaceYUV::ReleaseEGLImages() UID %d", mUID));
+  MOZ_ASSERT(aGLContext, "Missing GLContext!");
+
+  const auto& gle = gl::GLContextEGL::Cast(aGLContext);
+  const auto& egl = gle->mEgl;
+
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    if (mEGLImage[i] != LOCAL_EGL_NO_IMAGE) {
+      egl->fDestroyImage(mEGLImage[i]);
+      mEGLImage[i] = LOCAL_EGL_NO_IMAGE;
+    }
+  }
+}
+
+bool DMABufSurfaceYUV::CreateTexture(GLContext* aGLContext, int aPlane) {
+  LOGDMABUF(
+      ("DMABufSurfaceYUV::CreateTexture() UID %d plane %d", mUID, aPlane));
+  MOZ_ASSERT(!mTexture[aPlane], "Texture is already created!");
+  MOZ_ASSERT(aGLContext, "Missing GLContext!");
+
+  if (!CreateEGLImage(aGLContext, aPlane)) {
+    return false;
+  }
+  if (!aGLContext->MakeCurrent()) {
+    LOGDMABUF(("  Failed to make GL context current."));
+    return false;
+  }
+  aGLContext->fGenTextures(1, &mTexture[aPlane]);
+  const ScopedBindTexture savedTex(aGLContext, mTexture[aPlane]);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_S,
+                             LOCAL_GL_CLAMP_TO_EDGE);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_T,
+                             LOCAL_GL_CLAMP_TO_EDGE);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER,
+                             LOCAL_GL_LINEAR);
+  aGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER,
+                             LOCAL_GL_LINEAR);
+  aGLContext->fEGLImageTargetTexture2D(LOCAL_GL_TEXTURE_2D, mEGLImage[aPlane]);
+  mGL = aGLContext;
+  return true;
+}
+
+void DMABufSurfaceYUV::ReleaseTextures() {
+  LOGDMABUF(("DMABufSurfaceYUV::ReleaseTextures() UID %d", mUID));
+
+  FenceDelete();
+
+  bool textureActive = false;
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    if (mTexture[i] || mEGLImage[i]) {
+      textureActive = true;
+      break;
+    }
+  }
+
+  if (!textureActive) {
+    return;
+  }
+
+  if (!mGL) {
+#ifdef NIGHTLY_BUILD
+    MOZ_DIAGNOSTIC_ASSERT(mGL, "Missing GL context!");
+#else
+    NS_WARNING(
+        "DMABufSurfaceYUV::ReleaseTextures(): Missing GL context! We're "
+        "leaking textures!");
+    return;
+#endif
+  }
+
+  if (!mGL->MakeCurrent()) {
+    NS_WARNING(
+        "DMABufSurfaceYUV::ReleaseTextures(): MakeCurrent failed. We're "
+        "leaking textures!");
+    return;
+  }
+
+  mGL->fDeleteTextures(DMABUF_BUFFER_PLANES, mTexture);
+  for (int i = 0; i < DMABUF_BUFFER_PLANES; i++) {
+    mTexture[i] = 0;
+  }
+  ReleaseEGLImages(mGL);
+  mGL = nullptr;
+}
+
+bool DMABufSurfaceYUV::VerifyTextureCreation() {
+  LOGDMABUF(("DMABufSurfaceYUV::VerifyTextureCreation() UID %d", mUID));
+
+  StaticMutexAutoLock lock(sSnapshotContextMutex);
+  RefPtr<GLContext> context = ClaimSnapshotGLContext();
+  auto release = MakeScopeExit([&] {
+    ReleaseEGLImages(context);
+    ReturnSnapshotGLContext(context);
+  });
+
+  for (int i = 0; i < mBufferPlaneCount; i++) {
+    if (!CreateEGLImage(context, i)) {
+      LOGDMABUF(("  failed to create EGL image!"));
+      return false;
+    }
+  }
+
+  LOGDMABUF(("  success"));
+  return true;
+}
+
+gfx::SurfaceFormat DMABufSurfaceYUV::GetFormat() {
+  switch (mSurfaceType) {
+    case SURFACE_NV12:
+      return gfx::SurfaceFormat::NV12;
+    case SURFACE_YUV420:
+      return gfx::SurfaceFormat::YUV;
+    default:
+      NS_WARNING("DMABufSurfaceYUV::GetFormat(): Wrong surface format!");
+      return gfx::SurfaceFormat::UNKNOWN;
+  }
+}
+
+// GL uses swapped R and B components so report accordingly.
+gfx::SurfaceFormat DMABufSurfaceYUV::GetFormatGL() { return GetFormat(); }
+
+int DMABufSurfaceYUV::GetTextureCount() {
+  switch (mSurfaceType) {
+    case SURFACE_NV12:
+      return 2;
+    case SURFACE_YUV420:
+      return 3;
+    default:
+      NS_WARNING("DMABufSurfaceYUV::GetTextureCount(): Wrong surface format!");
+      return 1;
+  }
+}
+
+void DMABufSurfaceYUV::ReleaseSurface() {
+  LOGDMABUF(("DMABufSurfaceYUV::ReleaseSurface() UID %d", mUID));
+  ReleaseTextures();
+  ReleaseDMABuf();
+}
+
+already_AddRefed<gfx::DataSourceSurface>
+DMABufSurfaceYUV::GetAsSourceSurface() {
+  LOGDMABUF(("DMABufSurfaceYUV::GetAsSourceSurface UID %d", mUID));
+
+  StaticMutexAutoLock lock(sSnapshotContextMutex);
+  RefPtr<GLContext> context = ClaimSnapshotGLContext();
+  auto releaseTextures = mozilla::MakeScopeExit([&] {
+    ReleaseTextures();
+    ReturnSnapshotGLContext(context);
+  });
+
+  for (int i = 0; i < GetTextureCount(); i++) {
+    if (!GetTexture(i) && !CreateTexture(context, i)) {
+      LOGDMABUF(("GetAsSourceSurface: Failed to create DMABuf textures."));
+      return nullptr;
+    }
+  }
+
+  ScopedTexture scopedTex(context);
+  ScopedBindTexture boundTex(context, scopedTex.Texture());
+
+  gfx::IntSize size(GetWidth(), GetHeight());
+  context->fTexImage2D(LOCAL_GL_TEXTURE_2D, 0, LOCAL_GL_RGBA, size.width,
+                       size.height, 0, LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE,
+                       nullptr);
+
+  ScopedFramebufferForTexture autoFBForTex(context, scopedTex.Texture());
+  if (!autoFBForTex.IsComplete()) {
+    LOGDMABUF(("GetAsSourceSurface: ScopedFramebufferForTexture failed."));
+    return nullptr;
+  }
+
+  const gl::OriginPos destOrigin = gl::OriginPos::BottomLeft;
+  {
+    const ScopedBindFramebuffer bindFB(context, autoFBForTex.FB());
+    if (!context->BlitHelper()->Blit(this, size, destOrigin)) {
+      LOGDMABUF(("GetAsSourceSurface: Blit failed."));
+      return nullptr;
+    }
+  }
+
+  RefPtr<gfx::DataSourceSurface> source =
+      gfx::Factory::CreateDataSourceSurface(size, gfx::SurfaceFormat::B8G8R8A8);
+  if (NS_WARN_IF(!source)) {
+    LOGDMABUF(("GetAsSourceSurface: CreateDataSourceSurface failed."));
+    return nullptr;
+  }
+
+  ScopedBindFramebuffer bind(context, autoFBForTex.FB());
+  ReadPixelsIntoDataSurface(context, source);
+
+  return source.forget();
+}
diff --git a/widget/gtk/DMABufSurface.h b/widget/gtk/DMABufSurface.h
new file mode 100644
index 0000000000..e432cfad49
--- /dev/null
+++ b/widget/gtk/DMABufSurface.h
@@ -0,0 +1,362 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef DMABufSurface_h__
+#define DMABufSurface_h__
+
+#include <stdint.h>
+#include "mozilla/widget/nsWaylandDisplay.h"
+#include "mozilla/widget/va_drmcommon.h"
+#include "GLTypes.h"
+
+typedef void* EGLImageKHR;
+typedef void* EGLSyncKHR;
+
+#define DMABUF_BUFFER_PLANES 4
+
+#ifndef VA_FOURCC_NV12
+#  define VA_FOURCC_NV12 0x3231564E
+#endif
+#ifndef VA_FOURCC_YV12
+#  define VA_FOURCC_YV12 0x32315659
+#endif
+#ifndef VA_FOURCC_P010
+#  define VA_FOURCC_P010 0x30313050
+#endif
+
+namespace mozilla {
+namespace gfx {
+class DataSourceSurface;
+}
+namespace layers {
+class SurfaceDescriptor;
+class SurfaceDescriptorDMABuf;
+}  // namespace layers
+namespace gl {
+class GLContext;
+}
+}  // namespace mozilla
+
+typedef enum {
+  // Use alpha pixel format
+  DMABUF_ALPHA = 1 << 0,
+  // Surface is used as texture and may be also shared
+  DMABUF_TEXTURE = 1 << 1,
+  // Use modifiers. Such dmabuf surface may have more planes
+  // and complex internal structure (tiling/compression/etc.)
+  // so we can't do direct rendering to it.
+  DMABUF_USE_MODIFIERS = 1 << 3,
+} DMABufSurfaceFlags;
+
+class DMABufSurfaceRGBA;
+class DMABufSurfaceYUV;
+
+class DMABufSurface {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DMABufSurface)
+
+  enum SurfaceType {
+    SURFACE_RGBA,
+    SURFACE_NV12,
+    SURFACE_YUV420,
+  };
+
+  // Import surface from SurfaceDescriptor. This is usually
+  // used to copy surface from another process over IPC.
+  // When a global reference counter was created for the surface
+  // (see bellow) it's automatically referenced.
+  static already_AddRefed<DMABufSurface> CreateDMABufSurface(
+      const mozilla::layers::SurfaceDescriptor& aDesc);
+
+  // Export surface to another process via. SurfaceDescriptor.
+  virtual bool Serialize(
+      mozilla::layers::SurfaceDescriptor& aOutDescriptor) = 0;
+
+  virtual int GetWidth(int aPlane = 0) = 0;
+  virtual int GetHeight(int aPlane = 0) = 0;
+  virtual mozilla::gfx::SurfaceFormat GetFormat() = 0;
+  virtual mozilla::gfx::SurfaceFormat GetFormatGL() = 0;
+
+  virtual bool CreateTexture(mozilla::gl::GLContext* aGLContext,
+                             int aPlane = 0) = 0;
+  virtual void ReleaseTextures() = 0;
+  virtual GLuint GetTexture(int aPlane = 0) = 0;
+  virtual EGLImageKHR GetEGLImage(int aPlane = 0) = 0;
+
+  SurfaceType GetSurfaceType() { return mSurfaceType; };
+  virtual int GetTextureCount() = 0;
+
+  bool IsMapped(int aPlane = 0) { return (mMappedRegion[aPlane] != nullptr); };
+  void Unmap(int aPlane = 0);
+
+  virtual DMABufSurfaceRGBA* GetAsDMABufSurfaceRGBA() { return nullptr; }
+  virtual DMABufSurfaceYUV* GetAsDMABufSurfaceYUV() { return nullptr; }
+  virtual already_AddRefed<mozilla::gfx::DataSourceSurface>
+  GetAsSourceSurface() {
+    return nullptr;
+  }
+
+  virtual mozilla::gfx::YUVColorSpace GetYUVColorSpace() {
+    return mozilla::gfx::YUVColorSpace::Default;
+  };
+
+  bool IsFullRange() { return mColorRange == mozilla::gfx::ColorRange::FULL; };
+  void SetColorRange(mozilla::gfx::ColorRange aColorRange) {
+    mColorRange = aColorRange;
+  };
+
+  void FenceSet();
+  void FenceWait();
+  void FenceDelete();
+
+  // Set and get a global surface UID. The UID is shared across process
+  // and it's used to track surface lifetime in various parts of rendering
+  // engine.
+  uint32_t GetUID() const { return mUID; };
+
+  // Creates a global reference counter objects attached to the surface.
+  // It's created as unreferenced, i.e. IsGlobalRefSet() returns false
+  // right after GlobalRefCountCreate() call.
+  //
+  // The counter is shared by all surface instances across processes
+  // so it tracks global surface usage.
+  //
+  // The counter is automatically referenced when a new surface instance is
+  // created with SurfaceDescriptor (usually copied to another process over IPC)
+  // and it's unreferenced when surface is deleted.
+  //
+  // So without any additional GlobalRefAdd()/GlobalRefRelease() calls
+  // the IsGlobalRefSet() returns true if any other process use the surface.
+  void GlobalRefCountCreate();
+
+  // If global reference counter was created by GlobalRefCountCreate()
+  // returns true when there's an active surface reference.
+  bool IsGlobalRefSet() const;
+
+  // Add/Remove additional reference to the surface global reference counter.
+  void GlobalRefAdd();
+  void GlobalRefRelease();
+
+  // Release all underlying data.
+  virtual void ReleaseSurface() = 0;
+
+#ifdef DEBUG
+  virtual void DumpToFile(const char* pFile){};
+#endif
+
+  DMABufSurface(SurfaceType aSurfaceType);
+
+ protected:
+  virtual bool Create(const mozilla::layers::SurfaceDescriptor& aDesc) = 0;
+
+  // Import global ref count from IPC by file descriptor.
+  void GlobalRefCountImport(int aFd);
+  // Export global ref count by file descriptor. This adds global ref count
+  // reference to the surface.
+  // It's used when dmabuf surface is shared with another process via. IPC.
+  int GlobalRefCountExport();
+  void GlobalRefCountDelete();
+
+  void ReleaseDMABuf();
+
+  void* MapInternal(uint32_t aX, uint32_t aY, uint32_t aWidth, uint32_t aHeight,
+                    uint32_t* aStride, int aGbmFlags, int aPlane = 0);
+
+  // We want to keep number of opened file descriptors low so open/close
+  // DMABuf file handles only when we need them, i.e. when DMABuf is exported
+  // to another process or to EGL.
+  virtual bool OpenFileDescriptorForPlane(
+      const mozilla::MutexAutoLock& aProofOfLock, int aPlane) = 0;
+  virtual void CloseFileDescriptorForPlane(
+      const mozilla::MutexAutoLock& aProofOfLock, int aPlane,
+      bool aForceClose = false) = 0;
+  bool OpenFileDescriptors(const mozilla::MutexAutoLock& aProofOfLock);
+  void CloseFileDescriptors(const mozilla::MutexAutoLock& aProofOfLock,
+                            bool aForceClose = false);
+
+  virtual ~DMABufSurface();
+
+  SurfaceType mSurfaceType;
+  uint64_t mBufferModifiers[DMABUF_BUFFER_PLANES];
+
+  int mBufferPlaneCount;
+  int mDmabufFds[DMABUF_BUFFER_PLANES];
+  int32_t mDrmFormats[DMABUF_BUFFER_PLANES];
+  int32_t mStrides[DMABUF_BUFFER_PLANES];
+  int32_t mOffsets[DMABUF_BUFFER_PLANES];
+
+  struct gbm_bo* mGbmBufferObject[DMABUF_BUFFER_PLANES];
+  void* mMappedRegion[DMABUF_BUFFER_PLANES];
+  void* mMappedRegionData[DMABUF_BUFFER_PLANES];
+  uint32_t mMappedRegionStride[DMABUF_BUFFER_PLANES];
+
+  int mSyncFd;
+  EGLSyncKHR mSync;
+  RefPtr<mozilla::gl::GLContext> mGL;
+
+  int mGlobalRefCountFd;
+  uint32_t mUID;
+  mozilla::Mutex mSurfaceLock MOZ_UNANNOTATED;
+
+  mozilla::gfx::ColorRange mColorRange = mozilla::gfx::ColorRange::LIMITED;
+};
+
+class DMABufSurfaceRGBA : public DMABufSurface {
+ public:
+  static already_AddRefed<DMABufSurfaceRGBA> CreateDMABufSurface(
+      int aWidth, int aHeight, int aDMABufSurfaceFlags);
+
+  static already_AddRefed<DMABufSurface> CreateDMABufSurface(
+      mozilla::gl::GLContext* aGLContext, const EGLImageKHR aEGLImage,
+      int aWidth, int aHeight);
+
+  bool Serialize(mozilla::layers::SurfaceDescriptor& aOutDescriptor);
+
+  DMABufSurfaceRGBA* GetAsDMABufSurfaceRGBA() { return this; }
+
+  void Clear();
+
+  void ReleaseSurface();
+
+  bool CopyFrom(class DMABufSurface* aSourceSurface);
+
+  int GetWidth(int aPlane = 0) { return mWidth; };
+  int GetHeight(int aPlane = 0) { return mHeight; };
+  mozilla::gfx::SurfaceFormat GetFormat();
+  mozilla::gfx::SurfaceFormat GetFormatGL();
+  bool HasAlpha();
+
+  void* MapReadOnly(uint32_t aX, uint32_t aY, uint32_t aWidth, uint32_t aHeight,
+                    uint32_t* aStride = nullptr);
+  void* MapReadOnly(uint32_t* aStride = nullptr);
+  void* Map(uint32_t aX, uint32_t aY, uint32_t aWidth, uint32_t aHeight,
+            uint32_t* aStride = nullptr);
+  void* Map(uint32_t* aStride = nullptr);
+  void* GetMappedRegion(int aPlane = 0) { return mMappedRegion[aPlane]; };
+  uint32_t GetMappedRegionStride(int aPlane = 0) {
+    return mMappedRegionStride[aPlane];
+  };
+
+  bool CreateTexture(mozilla::gl::GLContext* aGLContext, int aPlane = 0);
+  void ReleaseTextures();
+  GLuint GetTexture(int aPlane = 0) { return mTexture; };
+  EGLImageKHR GetEGLImage(int aPlane = 0) { return mEGLImage; };
+
+  bool CreateWlBuffer();
+  void ReleaseWlBuffer();
+  wl_buffer* GetWlBuffer() { return mWlBuffer; };
+
+  int GetTextureCount() { return 1; };
+
+#ifdef DEBUG
+  virtual void DumpToFile(const char* pFile);
+#endif
+
+  DMABufSurfaceRGBA();
+
+ private:
+  ~DMABufSurfaceRGBA();
+
+  bool Create(int aWidth, int aHeight, int aDMABufSurfaceFlags);
+  bool Create(const mozilla::layers::SurfaceDescriptor& aDesc);
+  bool Create(mozilla::gl::GLContext* aGLContext, const EGLImageKHR aEGLImage,
+              int aWidth, int aHeight);
+
+  bool ImportSurfaceDescriptor(const mozilla::layers::SurfaceDescriptor& aDesc);
+
+  bool OpenFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
+                                  int aPlane);
+  void CloseFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
+                                   int aPlane, bool aForceClose);
+
+ private:
+  int mSurfaceFlags;
+
+  int mWidth;
+  int mHeight;
+  mozilla::widget::GbmFormat* mGmbFormat;
+
+  EGLImageKHR mEGLImage;
+  GLuint mTexture;
+  uint32_t mGbmBufferFlags;
+  wl_buffer* mWlBuffer;
+};
+
+class DMABufSurfaceYUV : public DMABufSurface {
+ public:
+  static already_AddRefed<DMABufSurfaceYUV> CreateYUVSurface(
+      int aWidth, int aHeight, void** aPixelData = nullptr,
+      int* aLineSizes = nullptr);
+
+  static already_AddRefed<DMABufSurfaceYUV> CreateYUVSurface(
+      const VADRMPRIMESurfaceDescriptor& aDesc, int aWidth, int aHeight);
+
+  bool Serialize(mozilla::layers::SurfaceDescriptor& aOutDescriptor);
+
+  DMABufSurfaceYUV* GetAsDMABufSurfaceYUV() { return this; };
+  already_AddRefed<mozilla::gfx::DataSourceSurface> GetAsSourceSurface();
+
+  int GetWidth(int aPlane = 0) { return mWidth[aPlane]; }
+  int GetHeight(int aPlane = 0) { return mHeight[aPlane]; }
+  mozilla::gfx::SurfaceFormat GetFormat();
+  mozilla::gfx::SurfaceFormat GetFormatGL();
+
+  bool CreateTexture(mozilla::gl::GLContext* aGLContext, int aPlane = 0);
+  void ReleaseTextures();
+
+  void ReleaseSurface();
+
+  GLuint GetTexture(int aPlane = 0) { return mTexture[aPlane]; };
+  EGLImageKHR GetEGLImage(int aPlane = 0) { return mEGLImage[aPlane]; };
+
+  int GetTextureCount();
+
+  void SetYUVColorSpace(mozilla::gfx::YUVColorSpace aColorSpace) {
+    mColorSpace = aColorSpace;
+  }
+  mozilla::gfx::YUVColorSpace GetYUVColorSpace() { return mColorSpace; }
+
+  DMABufSurfaceYUV();
+
+  bool UpdateYUVData(void** aPixelData, int* aLineSizes);
+  bool UpdateYUVData(const VADRMPRIMESurfaceDescriptor& aDesc, int aWidth,
+                     int aHeight);
+
+  bool VerifyTextureCreation();
+
+ private:
+  ~DMABufSurfaceYUV();
+
+  bool Create(const mozilla::layers::SurfaceDescriptor& aDesc);
+  bool Create(int aWidth, int aHeight, void** aPixelData, int* aLineSizes);
+  bool CreateYUVPlane(int aPlane, int aWidth, int aHeight, int aDrmFormat);
+  void UpdateYUVPlane(int aPlane, void* aPixelData, int aLineSize);
+
+  bool ImportSurfaceDescriptor(
+      const mozilla::layers::SurfaceDescriptorDMABuf& aDesc);
+
+  bool OpenFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
+                                  int aPlane);
+  void CloseFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
+                                   int aPlane, bool aForceClose);
+
+  bool CreateEGLImage(mozilla::gl::GLContext* aGLContext, int aPlane);
+  void ReleaseEGLImages(mozilla::gl::GLContext* aGLContext);
+
+  int mWidth[DMABUF_BUFFER_PLANES];
+  int mHeight[DMABUF_BUFFER_PLANES];
+  // Aligned size of the surface imported from VADRMPRIMESurfaceDescriptor.
+  // It's used only internally to create EGLImage as some GL drivers
+  // needs that (Bug 1724385).
+  int mWidthAligned[DMABUF_BUFFER_PLANES];
+  int mHeightAligned[DMABUF_BUFFER_PLANES];
+  EGLImageKHR mEGLImage[DMABUF_BUFFER_PLANES];
+  GLuint mTexture[DMABUF_BUFFER_PLANES];
+  mozilla::gfx::YUVColorSpace mColorSpace =
+      mozilla::gfx::YUVColorSpace::Default;
+};
+
+#endif
diff --git a/widget/gtk/GRefPtr.h b/widget/gtk/GRefPtr.h
new file mode 100644
index 0000000000..a109abe090
--- /dev/null
+++ b/widget/gtk/GRefPtr.h
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GRefPtr_h_
+#define GRefPtr_h_
+
+// Allows to use RefPtr<T> with various kinds of GObjects
+
+#include <gdk/gdk.h>
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+#include "mozilla/RefPtr.h"
+
+#ifdef MOZ_ENABLE_DBUS
+// TODO: Remove this (we should use GDBus instead, which is not deprecated).
+#  include <dbus/dbus-glib.h>
+#endif
+
+namespace mozilla {
+
+template <typename T>
+struct GObjectRefPtrTraits {
+  static void AddRef(T* aObject) { g_object_ref(aObject); }
+  static void Release(T* aObject) { g_object_unref(aObject); }
+};
+
+#define GOBJECT_TRAITS(type_) \
+  template <>                 \
+  struct RefPtrTraits<type_> : public GObjectRefPtrTraits<type_> {};
+
+GOBJECT_TRAITS(GtkWidget)
+GOBJECT_TRAITS(GFile)
+GOBJECT_TRAITS(GMenu)
+GOBJECT_TRAITS(GMenuItem)
+GOBJECT_TRAITS(GSimpleAction)
+GOBJECT_TRAITS(GSimpleActionGroup)
+GOBJECT_TRAITS(GDBusProxy)
+GOBJECT_TRAITS(GAppInfo)
+GOBJECT_TRAITS(GAppLaunchContext)
+GOBJECT_TRAITS(GdkDragContext)
+GOBJECT_TRAITS(GDBusMessage)
+GOBJECT_TRAITS(GdkPixbuf)
+GOBJECT_TRAITS(GCancellable)
+GOBJECT_TRAITS(GUnixFDList)
+
+#ifdef MOZ_ENABLE_DBUS
+GOBJECT_TRAITS(DBusGProxy)
+#endif
+
+#undef GOBJECT_TRAITS
+
+template <>
+struct RefPtrTraits<GVariant> {
+  static void AddRef(GVariant* aVariant) { g_variant_ref(aVariant); }
+  static void Release(GVariant* aVariant) { g_variant_unref(aVariant); }
+};
+
+template <>
+struct RefPtrTraits<GHashTable> {
+  static void AddRef(GHashTable* aObject) { g_hash_table_ref(aObject); }
+  static void Release(GHashTable* aObject) { g_hash_table_unref(aObject); }
+};
+
+template <>
+struct RefPtrTraits<GDBusNodeInfo> {
+  static void AddRef(GDBusNodeInfo* aObject) { g_dbus_node_info_ref(aObject); }
+  static void Release(GDBusNodeInfo* aObject) {
+    g_dbus_node_info_unref(aObject);
+  }
+};
+
+#ifdef MOZ_ENABLE_DBUS
+template <>
+struct RefPtrTraits<DBusGConnection> {
+  static void AddRef(DBusGConnection* aObject) {
+    dbus_g_connection_ref(aObject);
+  }
+  static void Release(DBusGConnection* aObject) {
+    dbus_g_connection_unref(aObject);
+  }
+};
+#endif
+
+}  // namespace mozilla
+
+#endif
diff --git a/widget/gtk/GUniquePtr.h b/widget/gtk/GUniquePtr.h
new file mode 100644
index 0000000000..0cd5de7b60
--- /dev/null
+++ b/widget/gtk/GUniquePtr.h
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GUniquePtr_h_
+#define GUniquePtr_h_
+
+// Provides GUniquePtr to g_free a given pointer.
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+
+struct GFreeDeleter {
+  constexpr GFreeDeleter() = default;
+  void operator()(GdkEventCrossing* aPtr) const {
+    gdk_event_free((GdkEvent*)aPtr);
+  }
+  void operator()(GdkEventKey* aPtr) const { gdk_event_free((GdkEvent*)aPtr); }
+  void operator()(GdkEvent* aPtr) const { gdk_event_free(aPtr); }
+  void operator()(GError* aPtr) const { g_error_free(aPtr); }
+  void operator()(void* aPtr) const { g_free(aPtr); }
+  void operator()(GtkPaperSize* aPtr) const { gtk_paper_size_free(aPtr); }
+};
+
+template <typename T>
+using GUniquePtr = UniquePtr<T, GFreeDeleter>;
+
+}  // namespace mozilla
+
+#endif
diff --git a/widget/gtk/GfxInfo.cpp b/widget/gtk/GfxInfo.cpp
new file mode 100644
index 0000000000..c3619f373f
--- /dev/null
+++ b/widget/gtk/GfxInfo.cpp
@@ -0,0 +1,1151 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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 "GfxInfo.h"
+
+#include <cctype>
+#include <errno.h>
+#include <unistd.h>
+#include <string>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <sys/wait.h>
+
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/SSE.h"
+#include "mozilla/Telemetry.h"
+#include "nsCRTGlue.h"
+#include "nsExceptionHandler.h"
+#include "nsPrintfCString.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsUnicharUtils.h"
+#include "nsWhitespaceTokenizer.h"
+#include "prenv.h"
+#include "WidgetUtilsGtk.h"
+#include "MediaCodecsSupport.h"
+
+#define EXIT_STATUS_BUFFER_TOO_SMALL 2
+#ifdef DEBUG
+bool fire_glxtest_process();
+#endif
+
+namespace mozilla::widget {
+
+#ifdef DEBUG
+NS_IMPL_ISUPPORTS_INHERITED(GfxInfo, GfxInfoBase, nsIGfxInfoDebug)
+#endif
+
+// these global variables will be set when firing the glxtest process
+int glxtest_pipe = -1;
+pid_t glxtest_pid = 0;
+
+// bits to use decoding codec information returned from glxtest
+constexpr int CODEC_HW_H264 = 1 << 4;
+constexpr int CODEC_HW_VP8 = 1 << 5;
+constexpr int CODEC_HW_VP9 = 1 << 6;
+constexpr int CODEC_HW_AV1 = 1 << 7;
+
+nsresult GfxInfo::Init() {
+  mGLMajorVersion = 0;
+  mGLMinorVersion = 0;
+  mHasTextureFromPixmap = false;
+  mIsMesa = false;
+  mIsAccelerated = true;
+  mIsWayland = false;
+  mIsXWayland = false;
+  mHasMultipleGPUs = false;
+  mGlxTestError = false;
+  mIsVAAPISupported = false;
+  return GfxInfoBase::Init();
+}
+
+void GfxInfo::AddCrashReportAnnotations() {
+  CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterVendorID,
+                                     mVendorId);
+  CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterDeviceID,
+                                     mDeviceId);
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::AdapterDriverVendor, mDriverVendor);
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::AdapterDriverVersion, mDriverVersion);
+  CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::IsWayland,
+                                     mIsWayland);
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::DesktopEnvironment,
+      GetDesktopEnvironmentIdentifier());
+
+  if (mHasMultipleGPUs) {
+    nsAutoCString note;
+    note.AppendLiteral("Has dual GPUs.");
+    if (!mSecondaryVendorId.IsEmpty()) {
+      note.AppendLiteral(" GPU #2: AdapterVendorID2: ");
+      note.Append(mSecondaryVendorId);
+      note.AppendLiteral(", AdapterDeviceID2: ");
+      note.Append(mSecondaryDeviceId);
+    }
+    CrashReporter::AppendAppNotesToCrashReport(note);
+  }
+}
+
+void GfxInfo::GetData() {
+  GfxInfoBase::GetData();
+
+  // to understand this function, see bug 639842. We retrieve the OpenGL driver
+  // information in a separate process to protect against bad drivers.
+
+  // if glxtest_pipe == -1, that means that we already read the information
+  if (glxtest_pipe == -1) return;
+
+  enum { buf_size = 2048 };
+  char buf[buf_size];
+  ssize_t bytesread = read(glxtest_pipe, &buf,
+                           buf_size - 1);  // -1 because we'll append a zero
+  close(glxtest_pipe);
+  glxtest_pipe = -1;
+
+  // bytesread < 0 would mean that the above read() call failed.
+  // This should never happen. If it did, the outcome would be to blocklist
+  // anyway.
+  if (bytesread < 0) {
+    bytesread = 0;
+  } else if (bytesread == buf_size - 1) {
+    gfxCriticalNote << "glxtest: read from pipe exceeded buffer size";
+  }
+
+  // let buf be a zero-terminated string
+  buf[bytesread] = 0;
+
+  // Wait for the glxtest process to finish. This serves 2 purposes:
+  // * avoid having a zombie glxtest process laying around
+  // * get the glxtest process status info.
+  int glxtest_status = 0;
+  bool wait_for_glxtest_process = true;
+  bool waiting_for_glxtest_process_failed = false;
+  int waitpid_errno = 0;
+  while (wait_for_glxtest_process) {
+    wait_for_glxtest_process = false;
+    if (waitpid(glxtest_pid, &glxtest_status, 0) == -1) {
+      waitpid_errno = errno;
+      if (waitpid_errno == EINTR) {
+        wait_for_glxtest_process = true;
+      } else {
+        // Bug 718629
+        // ECHILD happens when the glxtest process got reaped got reaped after a
+        // PR_CreateProcess as per bug 227246. This shouldn't matter, as we
+        // still seem to get the data from the pipe, and if we didn't, the
+        // outcome would be to blocklist anyway.
+        waiting_for_glxtest_process_failed = (waitpid_errno != ECHILD);
+      }
+    }
+  }
+
+  int exit_code = EXIT_FAILURE;
+  bool exited_with_error_code = false;
+  if (!waiting_for_glxtest_process_failed && WIFEXITED(glxtest_status)) {
+    exit_code = WEXITSTATUS(glxtest_status);
+    exited_with_error_code = exit_code != EXIT_SUCCESS;
+  }
+
+  bool received_signal =
+      !waiting_for_glxtest_process_failed && WIFSIGNALED(glxtest_status);
+
+  bool error = waiting_for_glxtest_process_failed || exited_with_error_code ||
+               received_signal;
+  bool errorLog = false;
+
+  nsCString glVendor;
+  nsCString glRenderer;
+  nsCString glVersion;
+  nsCString textureFromPixmap;
+  nsCString testType;
+
+  // Available if GLX_MESA_query_renderer is supported.
+  nsCString mesaVendor;
+  nsCString mesaDevice;
+  nsCString mesaAccelerated;
+  // Available if using a DRI-based libGL stack.
+  nsCString driDriver;
+  nsCString adapterRam;
+
+  nsCString drmRenderDevice;
+  nsCString isVAAPISupported;
+
+  nsCString ddxDriver;
+
+  AutoTArray<nsCString, 2> pciVendors;
+  AutoTArray<nsCString, 2> pciDevices;
+
+  nsCString* stringToFill = nullptr;
+  bool logString = false;
+
+  char* bufptr = buf;
+  while (true) {
+    char* line = NS_strtok("\n", &bufptr);
+    if (!line) break;
+    if (stringToFill) {
+      stringToFill->Assign(line);
+      stringToFill = nullptr;
+    } else if (logString) {
+      gfxCriticalNote << "glxtest: " << line;
+      logString = false;
+    } else if (!strcmp(line, "VENDOR")) {
+      stringToFill = &glVendor;
+    } else if (!strcmp(line, "RENDERER")) {
+      stringToFill = &glRenderer;
+    } else if (!strcmp(line, "VERSION")) {
+      stringToFill = &glVersion;
+    } else if (!strcmp(line, "TFP")) {
+      stringToFill = &textureFromPixmap;
+    } else if (!strcmp(line, "MESA_VENDOR_ID")) {
+      stringToFill = &mesaVendor;
+    } else if (!strcmp(line, "MESA_DEVICE_ID")) {
+      stringToFill = &mesaDevice;
+    } else if (!strcmp(line, "MESA_ACCELERATED")) {
+      stringToFill = &mesaAccelerated;
+    } else if (!strcmp(line, "MESA_VRAM")) {
+      stringToFill = &adapterRam;
+    } else if (!strcmp(line, "DDX_DRIVER")) {
+      stringToFill = &ddxDriver;
+    } else if (!strcmp(line, "DRI_DRIVER")) {
+      stringToFill = &driDriver;
+    } else if (!strcmp(line, "PCI_VENDOR_ID")) {
+      stringToFill = pciVendors.AppendElement();
+    } else if (!strcmp(line, "PCI_DEVICE_ID")) {
+      stringToFill = pciDevices.AppendElement();
+    } else if (!strcmp(line, "DRM_RENDERDEVICE")) {
+      stringToFill = &drmRenderDevice;
+    } else if (!strcmp(line, "VAAPI_SUPPORTED")) {
+      stringToFill = &isVAAPISupported;
+    } else if (!strcmp(line, "VAAPI_HWCODECS")) {
+      line = NS_strtok("\n", &bufptr);
+      if (!line) break;
+      int codecs = 0;
+      std::istringstream(line) >> codecs;
+      if (codecs & CODEC_HW_H264) {
+        media::MCSInfo::AddSupport(
+            media::MediaCodecsSupport::H264HardwareDecode);
+      }
+      if (codecs & CODEC_HW_VP8) {
+        media::MCSInfo::AddSupport(
+            media::MediaCodecsSupport::VP8HardwareDecode);
+      }
+      if (codecs & CODEC_HW_VP9) {
+        media::MCSInfo::AddSupport(
+            media::MediaCodecsSupport::VP9HardwareDecode);
+      }
+      if (codecs & CODEC_HW_AV1) {
+        media::MCSInfo::AddSupport(
+            media::MediaCodecsSupport::AV1HardwareDecode);
+      }
+    } else if (!strcmp(line, "TEST_TYPE")) {
+      stringToFill = &testType;
+    } else if (!strcmp(line, "WARNING")) {
+      logString = true;
+    } else if (!strcmp(line, "ERROR")) {
+      logString = true;
+      errorLog = true;
+    }
+  }
+
+  MOZ_ASSERT(pciDevices.Length() == pciVendors.Length(),
+             "Missing PCI vendors/devices");
+
+  size_t pciLen = std::min(pciVendors.Length(), pciDevices.Length());
+  mHasMultipleGPUs = pciLen > 1;
+
+  if (!strcmp(textureFromPixmap.get(), "TRUE")) mHasTextureFromPixmap = true;
+
+  // only useful for Linux kernel version check for FGLRX driver.
+  // assumes X client == X server, which is sad.
+  struct utsname unameobj {};
+  if (uname(&unameobj) >= 0) {
+    mOS.Assign(unameobj.sysname);
+    mOSRelease.Assign(unameobj.release);
+  }
+
+  const char* spoofedVendor = PR_GetEnv("MOZ_GFX_SPOOF_GL_VENDOR");
+  if (spoofedVendor) glVendor.Assign(spoofedVendor);
+  const char* spoofedRenderer = PR_GetEnv("MOZ_GFX_SPOOF_GL_RENDERER");
+  if (spoofedRenderer) glRenderer.Assign(spoofedRenderer);
+  const char* spoofedVersion = PR_GetEnv("MOZ_GFX_SPOOF_GL_VERSION");
+  if (spoofedVersion) glVersion.Assign(spoofedVersion);
+  const char* spoofedOS = PR_GetEnv("MOZ_GFX_SPOOF_OS");
+  if (spoofedOS) mOS.Assign(spoofedOS);
+  const char* spoofedOSRelease = PR_GetEnv("MOZ_GFX_SPOOF_OS_RELEASE");
+  if (spoofedOSRelease) mOSRelease.Assign(spoofedOSRelease);
+
+  // Scan the GL_VERSION string for the GL and driver versions.
+  nsCWhitespaceTokenizer tokenizer(glVersion);
+  while (tokenizer.hasMoreTokens()) {
+    nsCString token(tokenizer.nextToken());
+    unsigned int major = 0, minor = 0, revision = 0, patch = 0;
+    if (sscanf(token.get(), "%u.%u.%u.%u", &major, &minor, &revision, &patch) >=
+        2) {
+      // A survey of GL_VENDOR strings indicates that the first version is
+      // always the GL version, the second is usually the driver version.
+      if (mGLMajorVersion == 0) {
+        mGLMajorVersion = major;
+        mGLMinorVersion = minor;
+      } else if (mDriverVersion.IsEmpty()) {  // Not already spoofed.
+        mDriverVersion =
+            nsPrintfCString("%u.%u.%u.%u", major, minor, revision, patch);
+      }
+    }
+  }
+
+  if (mGLMajorVersion == 0) {
+    NS_WARNING("Failed to parse GL version!");
+  }
+
+  mDrmRenderDevice = std::move(drmRenderDevice);
+  mIsVAAPISupported = isVAAPISupported.Equals("TRUE");
+  mTestType = std::move(testType);
+
+  // Mesa always exposes itself in the GL_VERSION string, but not always the
+  // GL_VENDOR string.
+  mIsMesa = glVersion.Find("Mesa") != -1;
+
+  // We need to use custom driver vendor IDs for mesa so we can treat them
+  // differently than the proprietary drivers.
+  if (mIsMesa) {
+    mIsAccelerated = !mesaAccelerated.Equals("FALSE");
+    // Process software rasterizers before the DRI driver string; we may be
+    // forcing software rasterization on a DRI-accelerated X server by using
+    // LIBGL_ALWAYS_SOFTWARE or a similar restriction.
+    if (strcasestr(glRenderer.get(), "llvmpipe")) {
+      CopyUTF16toUTF8(
+          GfxDriverInfo::GetDriverVendor(DriverVendor::MesaLLVMPipe),
+          mDriverVendor);
+      mIsAccelerated = false;
+    } else if (strcasestr(glRenderer.get(), "softpipe")) {
+      CopyUTF16toUTF8(
+          GfxDriverInfo::GetDriverVendor(DriverVendor::MesaSoftPipe),
+          mDriverVendor);
+      mIsAccelerated = false;
+    } else if (strcasestr(glRenderer.get(), "software rasterizer")) {
+      CopyUTF16toUTF8(GfxDriverInfo::GetDriverVendor(DriverVendor::MesaSWRast),
+                      mDriverVendor);
+      mIsAccelerated = false;
+    } else if (!mIsAccelerated) {
+      CopyUTF16toUTF8(
+          GfxDriverInfo::GetDriverVendor(DriverVendor::MesaSWUnknown),
+          mDriverVendor);
+    } else if (!driDriver.IsEmpty()) {
+      mDriverVendor = nsPrintfCString("mesa/%s", driDriver.get());
+    } else {
+      // Some other mesa configuration where we couldn't get enough info.
+      NS_WARNING("Failed to detect Mesa driver being used!");
+      CopyUTF16toUTF8(GfxDriverInfo::GetDriverVendor(DriverVendor::MesaUnknown),
+                      mDriverVendor);
+    }
+
+    if (!mesaVendor.IsEmpty()) {
+      mVendorId = mesaVendor;
+    }
+
+    if (!mesaDevice.IsEmpty()) {
+      mDeviceId = mesaDevice;
+    }
+
+    if (!mIsAccelerated && mVendorId.IsEmpty()) {
+      mVendorId.Assign(glVendor.get());
+    }
+
+    if (!mIsAccelerated && mDeviceId.IsEmpty()) {
+      mDeviceId.Assign(glRenderer.get());
+    }
+  } else if (glVendor.EqualsLiteral("NVIDIA Corporation")) {
+    CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(DeviceVendor::NVIDIA),
+                    mVendorId);
+    mDriverVendor.AssignLiteral("nvidia/unknown");
+    // TODO: Use NV-CONTROL X11 extension to query Device ID and VRAM.
+  } else if (glVendor.EqualsLiteral("ATI Technologies Inc.")) {
+    CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(DeviceVendor::ATI),
+                    mVendorId);
+    mDriverVendor.AssignLiteral("ati/unknown");
+    // TODO: Look into ways to find the device ID on FGLRX.
+  } else {
+    NS_WARNING("Failed to detect GL vendor!");
+  }
+
+  if (!adapterRam.IsEmpty()) {
+    mAdapterRAM = (uint32_t)atoi(adapterRam.get());
+  }
+
+  // If we have the DRI driver, we can derive the vendor ID from that if needed.
+  if (mVendorId.IsEmpty() && !driDriver.IsEmpty()) {
+    const char* nvidiaDrivers[] = {"nouveau", "tegra", nullptr};
+    for (size_t i = 0; nvidiaDrivers[i]; ++i) {
+      if (driDriver.Equals(nvidiaDrivers[i])) {
+        CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(DeviceVendor::NVIDIA),
+                        mVendorId);
+        break;
+      }
+    }
+
+    if (mVendorId.IsEmpty()) {
+      const char* intelDrivers[] = {"iris", "crocus", "i915", "i965",
+                                    "i810", "intel",  nullptr};
+      for (size_t i = 0; intelDrivers[i]; ++i) {
+        if (driDriver.Equals(intelDrivers[i])) {
+          CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(DeviceVendor::Intel),
+                          mVendorId);
+          break;
+        }
+      }
+    }
+
+    if (mVendorId.IsEmpty()) {
+      const char* amdDrivers[] = {"r600",   "r200",     "r100",
+                                  "radeon", "radeonsi", nullptr};
+      for (size_t i = 0; amdDrivers[i]; ++i) {
+        if (driDriver.Equals(amdDrivers[i])) {
+          CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(DeviceVendor::ATI),
+                          mVendorId);
+          break;
+        }
+      }
+    }
+
+    if (mVendorId.IsEmpty()) {
+      if (driDriver.EqualsLiteral("freedreno")) {
+        CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(DeviceVendor::Qualcomm),
+                        mVendorId);
+      }
+    }
+  }
+
+  // If we still don't have a vendor ID, we can try the PCI vendor list.
+  if (mVendorId.IsEmpty()) {
+    if (pciVendors.IsEmpty()) {
+      gfxCriticalNote << "No GPUs detected via PCI";
+    } else {
+      for (size_t i = 0; i < pciVendors.Length(); ++i) {
+        if (mVendorId.IsEmpty()) {
+          mVendorId = pciVendors[i];
+        } else if (mVendorId != pciVendors[i]) {
+          gfxCriticalNote << "More than 1 GPU vendor detected via PCI, cannot "
+                             "deduce vendor";
+          mVendorId.Truncate();
+          break;
+        }
+      }
+    }
+  }
+
+  // If we know the vendor ID, but didn't get a device ID, we can guess from the
+  // PCI device list.
+  if (mDeviceId.IsEmpty() && !mVendorId.IsEmpty()) {
+    for (size_t i = 0; i < pciLen; ++i) {
+      if (mVendorId.Equals(pciVendors[i])) {
+        if (mDeviceId.IsEmpty()) {
+          mDeviceId = pciDevices[i];
+        } else if (mDeviceId != pciDevices[i]) {
+          gfxCriticalNote << "More than 1 GPU from same vendor detected via "
+                             "PCI, cannot deduce device";
+          mDeviceId.Truncate();
+          break;
+        }
+      }
+    }
+  }
+
+  // Assuming we know the vendor, we should check for a secondary card.
+  if (!mVendorId.IsEmpty()) {
+    if (pciLen > 2) {
+      gfxCriticalNote
+          << "More than 2 GPUs detected via PCI, secondary GPU is arbitrary";
+    }
+    for (size_t i = 0; i < pciLen; ++i) {
+      if (!mVendorId.Equals(pciVendors[i]) ||
+          (!mDeviceId.IsEmpty() && !mDeviceId.Equals(pciDevices[i]))) {
+        mSecondaryVendorId = pciVendors[i];
+        mSecondaryDeviceId = pciDevices[i];
+        break;
+      }
+    }
+  }
+
+  // If we couldn't choose, log them.
+  if (mVendorId.IsEmpty()) {
+    for (size_t i = 0; i < pciLen; ++i) {
+      gfxCriticalNote << "PCI candidate " << pciVendors[i].get() << "/"
+                      << pciDevices[i].get();
+    }
+  }
+
+  // Fallback to GL_VENDOR and GL_RENDERER.
+  if (mVendorId.IsEmpty()) {
+    mVendorId.Assign(glVendor.get());
+  }
+  if (mDeviceId.IsEmpty()) {
+    mDeviceId.Assign(glRenderer.get());
+  }
+
+  mAdapterDescription.Assign(glRenderer);
+
+  // Make a best effort guess at whether or not we are using the XWayland compat
+  // layer. For all intents and purposes, we should otherwise believe we are
+  // using X11.
+  mIsWayland = GdkIsWaylandDisplay();
+  mIsXWayland = IsXWaylandProtocol();
+
+  if (!ddxDriver.IsEmpty()) {
+    PRInt32 start = 0;
+    PRInt32 loc = ddxDriver.Find(";", start);
+    while (loc != kNotFound) {
+      nsCString line(ddxDriver.get() + start, loc - start);
+      mDdxDrivers.AppendElement(std::move(line));
+
+      start = loc + 1;
+      loc = ddxDriver.Find(";", start);
+    }
+  }
+
+  if (error || errorLog || mTestType.IsEmpty()) {
+    if (!mAdapterDescription.IsEmpty()) {
+      mAdapterDescription.AppendLiteral(" (See failure log)");
+    } else {
+      mAdapterDescription.AppendLiteral("See failure log");
+    }
+
+    mGlxTestError = true;
+  }
+
+  if (error) {
+    nsAutoCString msg("glxtest: process failed");
+    if (waiting_for_glxtest_process_failed) {
+      msg.AppendPrintf(" (waitpid failed with errno=%d for pid %d)",
+                       waitpid_errno, glxtest_pid);
+    }
+
+    if (exited_with_error_code) {
+      if (exit_code == EXIT_STATUS_BUFFER_TOO_SMALL) {
+        msg.AppendLiteral(" (buffer too small)");
+      } else {
+        msg.AppendPrintf(" (exited with status %d)",
+                         WEXITSTATUS(glxtest_status));
+      }
+    }
+    if (received_signal) {
+      msg.AppendPrintf(" (received signal %d)", WTERMSIG(glxtest_status));
+    }
+
+    gfxCriticalNote << msg.get();
+  }
+
+  AddCrashReportAnnotations();
+}
+
+const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
+  if (!sDriverInfo->Length()) {
+    // Mesa 10.0 provides the GLX_MESA_query_renderer extension, which allows us
+    // to query device IDs backing a GL context for blocklisting.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::All,
+        GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(10, 0, 0, 0), "FEATURE_FAILURE_OLD_MESA",
+        "Mesa 10.0");
+
+    // NVIDIA Mesa baseline (see bug 1714391).
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaNouveau, DeviceFamily::All,
+        GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(11, 0, 0, 0), "FEATURE_FAILURE_OLD_NV_MESA",
+        "Mesa 11.0");
+
+    // NVIDIA baseline (ported from old blocklist)
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::NvidiaAll,
+        GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(257, 21, 0, 0), "FEATURE_FAILURE_OLD_NVIDIA",
+        "NVIDIA 257.21");
+
+    // fglrx baseline (chosen arbitrarily as 2013-07-22 release).
+    APPEND_TO_DRIVER_BLOCKLIST(
+        OperatingSystem::Linux, DeviceFamily::AtiAll,
+        GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(13, 15, 100, 1), "FEATURE_FAILURE_OLD_FGLRX",
+        "fglrx 13.15.100.1");
+
+    ////////////////////////////////////
+    // FEATURE_WEBRENDER
+
+    // All Mesa software drivers, they should get Software WebRender instead.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::SoftwareMesaAll, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0), "FEATURE_FAILURE_SOFTWARE_GL",
+        "");
+
+    // Older generation Intel devices do not perform well with WebRender.
+    APPEND_TO_DRIVER_BLOCKLIST(
+        OperatingSystem::Linux, DeviceFamily::IntelWebRenderBlocked,
+        nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0), "INTEL_DEVICE_GEN5_OR_OLDER",
+        "");
+
+    // Nvidia Mesa baseline, see bug 1563859.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::NvidiaAll,
+        nsIGfxInfo::FEATURE_WEBRENDER,
+        nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
+        V(18, 2, 0, 0), "FEATURE_FAILURE_WEBRENDER_OLD_MESA", "Mesa 18.2.0.0");
+
+    // Disable on all older Nvidia drivers due to stability issues.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::NvidiaAll,
+        nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_LESS_THAN, V(460, 82, 0, 0),
+        "FEATURE_FAILURE_WEBRENDER_OLD_NVIDIA", "460.82.0");
+
+    // Older generation NVIDIA devices do not perform well with WebRender.
+    APPEND_TO_DRIVER_BLOCKLIST(
+        OperatingSystem::Linux, DeviceFamily::NvidiaWebRenderBlocked,
+        nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0),
+        "NVIDIA_EARLY_TESLA_AND_C67_C68", "");
+
+    // Mesa baseline, chosen arbitrarily. Linux users are generally good about
+    // updating their Mesa libraries so we don't want to arbitarily support
+    // WebRender on old drivers with outstanding bugs to work around.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_WEBRENDER,
+        nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
+        V(17, 0, 0, 0), "FEATURE_FAILURE_WEBRENDER_OLD_MESA", "Mesa 17.0.0.0");
+
+    // Mesa baseline for non-Intel/NVIDIA/ATI devices. These other devices will
+    // often have less mature drivers so let's block older Mesa versions.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaNonIntelNvidiaAtiAll,
+        DeviceFamily::All, nsIGfxInfo::FEATURE_WEBRENDER,
+        nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
+        V(22, 2, 0, 0), "FEATURE_FAILURE_WEBRENDER_OLD_MESA_OTHER",
+        "Mesa 22.2.0.0");
+
+    // Bug 1690568 / Bug 1393793 - Require Mesa 17.3.0+ for devices using the
+    // AMD r600 driver to avoid shader compilation issues.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaR600, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_WEBRENDER,
+        nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
+        V(17, 3, 0, 0), "FEATURE_FAILURE_WEBRENDER_OLD_MESA_R600",
+        "Mesa 17.3.0.0");
+
+    // Disable on all ATI devices not using Mesa for now.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::AtiAll,
+        nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0),
+        "FEATURE_FAILURE_WEBRENDER_NO_LINUX_ATI", "");
+
+    // Bug 1673939 - Garbled text on RS880 GPUs with Mesa drivers.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::AmdR600,
+        nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0),
+        "FEATURE_FAILURE_WEBRENDER_BUG_1673939",
+        "https://gitlab.freedesktop.org/mesa/mesa/-/issues/3720");
+
+    // Bug 1635186 - Poor performance with video playing in a background window
+    // on XWayland. Keep in sync with FEATURE_X11_EGL below to only enable them
+    // together by default. Only Mesa and Nvidia binary drivers are expected
+    // on Wayland rigth now.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::XWayland, DriverVendor::MesaAll, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_WEBRENDER,
+        nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
+        V(21, 0, 0, 0), "FEATURE_FAILURE_WEBRENDER_BUG_1635186",
+        "Mesa 21.0.0.0");
+
+    ////////////////////////////////////
+    // FEATURE_WEBRENDER_COMPOSITOR
+    APPEND_TO_DRIVER_BLOCKLIST(
+        OperatingSystem::Linux, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_WEBRENDER_COMPOSITOR,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_FAILURE_WEBRENDER_COMPOSITOR_DISABLED", "");
+
+    ////////////////////////////////////
+    // FEATURE_X11_EGL
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_X11_EGL, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(21, 0, 0, 0), "FEATURE_ROLLOUT_X11_EGL_MESA",
+        "Mesa 21.0.0.0");
+
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::NvidiaAll,
+        nsIGfxInfo::FEATURE_X11_EGL, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(470, 82, 0, 0),
+        "FEATURE_ROLLOUT_X11_EGL_NVIDIA_BINARY", "470.82.0");
+
+    // Disable on all AMD devices not using Mesa.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::AtiAll,
+        nsIGfxInfo::FEATURE_X11_EGL, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0),
+        "FEATURE_FAILURE_X11_EGL_NO_LINUX_ATI", "");
+
+    ////////////////////////////////////
+    // FEATURE_DMABUF
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::NvidiaAll,
+        nsIGfxInfo::FEATURE_DMABUF, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
+        DRIVER_LESS_THAN, V(495, 44, 0, 0), "FEATURE_FAILURE_NO_GBM",
+        "495.44.0");
+
+    ////////////////////////////////////
+    // FEATURE_DMABUF_SURFACE_EXPORT
+    // Disabled due to:
+    // https://gitlab.freedesktop.org/mesa/mesa/-/issues/6666
+    // https://gitlab.freedesktop.org/mesa/mesa/-/issues/6796
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::AtiAll,
+        nsIGfxInfo::FEATURE_DMABUF_SURFACE_EXPORT,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_FAILURE_BROKEN_DRIVER", "");
+
+    // Disabled due to:
+    // https://gitlab.freedesktop.org/mesa/mesa/-/issues/6688
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::IntelAll,
+        nsIGfxInfo::FEATURE_DMABUF_SURFACE_EXPORT,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_FAILURE_BROKEN_DRIVER", "");
+
+    // Disabled due to:
+    // https://gitlab.freedesktop.org/mesa/mesa/-/issues/6988
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::QualcommAll,
+        nsIGfxInfo::FEATURE_DMABUF_SURFACE_EXPORT,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_FAILURE_BROKEN_DRIVER", "");
+
+    ////////////////////////////////////
+    // FEATURE_HARDWARE_VIDEO_DECODING
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaAll, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
+        nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
+        V(21, 0, 0, 0), "FEATURE_HARDWARE_VIDEO_DECODING_MESA",
+        "Mesa 21.0.0.0");
+
+    // Disable on all NVIDIA hardware
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::All, DeviceFamily::NvidiaAll,
+        nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_HARDWARE_VIDEO_DECODING_NO_LINUX_NVIDIA", "");
+
+    // Disable on all AMD devices not using Mesa.
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::NonMesaAll, DeviceFamily::AtiAll,
+        nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_HARDWARE_VIDEO_DECODING_NO_LINUX_AMD", "");
+
+    // Disable on Release/late Beta
+#if !defined(EARLY_BETA_OR_EARLIER)
+    APPEND_TO_DRIVER_BLOCKLIST(OperatingSystem::Linux, DeviceFamily::All,
+                               nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
+                               nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+                               DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0),
+                               "FEATURE_HARDWARE_VIDEO_DECODING_DISABLE", "");
+#endif
+
+    ////////////////////////////////////
+    // FEATURE_WEBRENDER_PARTIAL_PRESENT
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::X11, DriverVendor::NonMesaAll, DeviceFamily::NvidiaAll,
+        nsIGfxInfo::FEATURE_WEBRENDER_PARTIAL_PRESENT,
+        nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
+        V(0, 0, 0, 0), "FEATURE_ROLLOUT_WR_PARTIAL_PRESENT_NVIDIA_BINARY", "");
+
+    ////////////////////////////////////
+
+    APPEND_TO_DRIVER_BLOCKLIST_EXT(
+        OperatingSystem::Linux, ScreenSizeStatus::All, BatteryStatus::All,
+        WindowProtocol::All, DriverVendor::MesaNouveau, DeviceFamily::All,
+        nsIGfxInfo::FEATURE_THREADSAFE_GL, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
+        DRIVER_COMPARISON_IGNORED, V(0, 0, 0, 0),
+        "FEATURE_FAILURE_THREADSAFE_GL", "");
+  }
+  return *sDriverInfo;
+}
+
+bool GfxInfo::DoesWindowProtocolMatch(const nsAString& aBlocklistWindowProtocol,
+                                      const nsAString& aWindowProtocol) {
+  if (mIsWayland &&
+      aBlocklistWindowProtocol.Equals(
+          GfxDriverInfo::GetWindowProtocol(WindowProtocol::WaylandAll),
+          nsCaseInsensitiveStringComparator)) {
+    return true;
+  }
+  if (!mIsWayland &&
+      aBlocklistWindowProtocol.Equals(
+          GfxDriverInfo::GetWindowProtocol(WindowProtocol::X11All),
+          nsCaseInsensitiveStringComparator)) {
+    return true;
+  }
+  return GfxInfoBase::DoesWindowProtocolMatch(aBlocklistWindowProtocol,
+                                              aWindowProtocol);
+}
+
+bool GfxInfo::DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
+                                    const nsAString& aDriverVendor) {
+  if (mIsMesa) {
+    if (aBlocklistVendor.Equals(
+            GfxDriverInfo::GetDriverVendor(DriverVendor::MesaAll),
+            nsCaseInsensitiveStringComparator)) {
+      return true;
+    }
+    if (mIsAccelerated &&
+        aBlocklistVendor.Equals(
+            GfxDriverInfo::GetDriverVendor(DriverVendor::HardwareMesaAll),
+            nsCaseInsensitiveStringComparator)) {
+      return true;
+    }
+    if (!mIsAccelerated &&
+        aBlocklistVendor.Equals(
+            GfxDriverInfo::GetDriverVendor(DriverVendor::SoftwareMesaAll),
+            nsCaseInsensitiveStringComparator)) {
+      return true;
+    }
+    if (aBlocklistVendor.Equals(GfxDriverInfo::GetDriverVendor(
+                                    DriverVendor::MesaNonIntelNvidiaAtiAll),
+                                nsCaseInsensitiveStringComparator)) {
+      return !mVendorId.Equals("0x8086") && !mVendorId.Equals("0x10de") &&
+             !mVendorId.Equals("0x1002");
+    }
+  }
+  if (!mIsMesa && aBlocklistVendor.Equals(
+                      GfxDriverInfo::GetDriverVendor(DriverVendor::NonMesaAll),
+                      nsCaseInsensitiveStringComparator)) {
+    return true;
+  }
+  return GfxInfoBase::DoesDriverVendorMatch(aBlocklistVendor, aDriverVendor);
+}
+
+nsresult GfxInfo::GetFeatureStatusImpl(
+    int32_t aFeature, int32_t* aStatus, nsAString& aSuggestedDriverVersion,
+    const nsTArray<GfxDriverInfo>& aDriverInfo, nsACString& aFailureId,
+    OperatingSystem* aOS /* = nullptr */)
+
+{
+  NS_ENSURE_ARG_POINTER(aStatus);
+  *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
+  aSuggestedDriverVersion.SetIsVoid(true);
+  OperatingSystem os = OperatingSystem::Linux;
+  if (aOS) *aOS = os;
+
+  if (sShutdownOccurred) {
+    return NS_OK;
+  }
+
+  GetData();
+
+  if (aFeature == nsIGfxInfo::FEATURE_BACKDROP_FILTER) {
+    *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
+    return NS_OK;
+  }
+
+  if (mGlxTestError) {
+    // If glxtest failed, block all features by default.
+    *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
+    aFailureId = "FEATURE_FAILURE_GLXTEST_FAILED";
+    return NS_OK;
+  }
+
+  if (mGLMajorVersion == 1) {
+    // We're on OpenGL 1. In most cases that indicates really old hardware.
+    // We better block them, rather than rely on them to fail gracefully,
+    // because they don't! see bug 696636
+    *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
+    aFailureId = "FEATURE_FAILURE_OPENGL_1";
+    return NS_OK;
+  }
+
+  // Blocklist software GL implementations from using layers acceleration.
+  // On the test infrastructure, we'll force-enable layers acceleration.
+  if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS && !mIsAccelerated &&
+      !PR_GetEnv("MOZ_LAYERS_ALLOW_SOFTWARE_GL")) {
+    *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
+    aFailureId = "FEATURE_FAILURE_SOFTWARE_GL";
+    return NS_OK;
+  }
+
+  if (aFeature == nsIGfxInfo::FEATURE_WEBRENDER) {
+    // Don't try Webrender on devices where we are guaranteed to fail.
+    if (mGLMajorVersion < 3) {
+      *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
+      aFailureId = "FEATURE_FAILURE_OPENGL_LESS_THAN_3";
+      return NS_OK;
+    }
+
+    // Bug 1710400: Disable Webrender on the deprecated Intel DDX driver
+    for (const nsCString& driver : mDdxDrivers) {
+      if (strcasestr(driver.get(), "Intel")) {
+        *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
+        aFailureId = "FEATURE_FAILURE_DDX_INTEL";
+        return NS_OK;
+      }
+    }
+  }
+
+  if (aFeature == nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING &&
+      !mIsVAAPISupported) {
+    *aStatus = nsIGfxInfo::FEATURE_BLOCKED_PLATFORM_TEST;
+    aFailureId = "FEATURE_FAILURE_VIDEO_DECODING_TEST_FAILED";
+    return NS_OK;
+  }
+
+  return GfxInfoBase::GetFeatureStatusImpl(
+      aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, aFailureId, &os);
+}
+
+NS_IMETHODIMP
+GfxInfo::GetD2DEnabled(bool* aEnabled) { return NS_ERROR_FAILURE; }
+
+NS_IMETHODIMP
+GfxInfo::GetDWriteEnabled(bool* aEnabled) { return NS_ERROR_FAILURE; }
+
+NS_IMETHODIMP
+GfxInfo::GetDWriteVersion(nsAString& aDwriteVersion) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP GfxInfo::GetHasBattery(bool* aHasBattery) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetEmbeddedInFirefoxReality(bool* aEmbeddedInFirefoxReality) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetCleartypeParameters(nsAString& aCleartypeParams) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetWindowProtocol(nsAString& aWindowProtocol) {
+  GetData();
+  if (mIsWayland) {
+    aWindowProtocol = GfxDriverInfo::GetWindowProtocol(WindowProtocol::Wayland);
+  } else if (mIsXWayland) {
+    aWindowProtocol =
+        GfxDriverInfo::GetWindowProtocol(WindowProtocol::XWayland);
+  } else {
+    aWindowProtocol = GfxDriverInfo::GetWindowProtocol(WindowProtocol::X11);
+  }
+  Telemetry::ScalarSet(Telemetry::ScalarID::GFX_LINUX_WINDOW_PROTOCOL,
+                       aWindowProtocol);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetDesktopEnvironment(nsAString& aDesktopEnvironment) {
+  CopyUTF8toUTF16(GetDesktopEnvironmentIdentifier(), aDesktopEnvironment);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetTestType(nsAString& aTestType) {
+  GetData();
+  AppendASCIItoUTF16(mTestType, aTestType);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDescription(nsAString& aAdapterDescription) {
+  GetData();
+  AppendASCIItoUTF16(mAdapterDescription, aAdapterDescription);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDescription2(nsAString& aAdapterDescription) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterRAM(uint32_t* aAdapterRAM) {
+  GetData();
+  *aAdapterRAM = mAdapterRAM;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterRAM2(uint32_t* aAdapterRAM) { return NS_ERROR_FAILURE; }
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriver(nsAString& aAdapterDriver) {
+  aAdapterDriver.Truncate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
+  GetData();
+  CopyASCIItoUTF16(mDriverVendor, aAdapterDriverVendor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
+  GetData();
+  CopyASCIItoUTF16(mDriverVersion, aAdapterDriverVersion);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriverVersion2(nsAString& aAdapterDriverVersion) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriverDate(nsAString& aAdapterDriverDate) {
+  aAdapterDriverDate.Truncate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDriverDate2(nsAString& aAdapterDriverDate) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterVendorID(nsAString& aAdapterVendorID) {
+  GetData();
+  CopyUTF8toUTF16(mVendorId, aAdapterVendorID);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterVendorID2(nsAString& aAdapterVendorID) {
+  GetData();
+  CopyUTF8toUTF16(mSecondaryVendorId, aAdapterVendorID);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDeviceID(nsAString& aAdapterDeviceID) {
+  GetData();
+  CopyUTF8toUTF16(mDeviceId, aAdapterDeviceID);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterDeviceID2(nsAString& aAdapterDeviceID) {
+  GetData();
+  CopyUTF8toUTF16(mSecondaryDeviceId, aAdapterDeviceID);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterSubsysID(nsAString& aAdapterSubsysID) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetAdapterSubsysID2(nsAString& aAdapterSubsysID) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active) {
+  // This is never the case, as the active GPU should be the primary GPU.
+  *aIsGPU2Active = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+GfxInfo::GetDrmRenderDevice(nsACString& aDrmRenderDevice) {
+  GetData();
+  aDrmRenderDevice.Assign(mDrmRenderDevice);
+  return NS_OK;
+}
+
+#ifdef DEBUG
+
+// Implement nsIGfxInfoDebug
+// We don't support spoofing anything on Linux
+
+NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString& aVendorID) {
+  GetData();
+  CopyUTF16toUTF8(aVendorID, mVendorId);
+  mIsAccelerated = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString& aDeviceID) {
+  GetData();
+  CopyUTF16toUTF8(aDeviceID, mDeviceId);
+  return NS_OK;
+}
+
+NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString& aDriverVersion) {
+  GetData();
+  CopyUTF16toUTF8(aDriverVersion, mDriverVersion);
+  return NS_OK;
+}
+
+NS_IMETHODIMP GfxInfo::SpoofOSVersion(uint32_t aVersion) {
+  // We don't support OS versioning on Linux. There's just "Linux".
+  return NS_OK;
+}
+
+NS_IMETHODIMP GfxInfo::FireTestProcess() {
+  // If the pid is zero, then we have never run the test process to query for
+  // driver information. This would normally be run on startup, but we need to
+  // manually invoke it for XPC shell tests.
+  if (glxtest_pid == 0) {
+    fire_glxtest_process();
+  }
+  return NS_OK;
+}
+
+#endif
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/GfxInfo.h b/widget/gtk/GfxInfo.h
new file mode 100644
index 0000000000..eae95579b2
--- /dev/null
+++ b/widget/gtk/GfxInfo.h
@@ -0,0 +1,124 @@
+/* vim: se cin sw=2 ts=2 et : */
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WIDGET_GTK_GFXINFO_h__
+#define WIDGET_GTK_GFXINFO_h__
+
+#include "GfxInfoBase.h"
+#include "nsString.h"
+
+namespace mozilla {
+namespace widget {
+
+class GfxInfo final : public GfxInfoBase {
+ public:
+  // We only declare the subset of nsIGfxInfo that we actually implement. The
+  // rest is brought forward from GfxInfoBase.
+  NS_IMETHOD GetD2DEnabled(bool* aD2DEnabled) override;
+  NS_IMETHOD GetDWriteEnabled(bool* aDWriteEnabled) override;
+  NS_IMETHOD GetDWriteVersion(nsAString& aDwriteVersion) override;
+  NS_IMETHOD GetEmbeddedInFirefoxReality(
+      bool* aEmbeddedInFirefoxReality) override;
+  NS_IMETHOD GetHasBattery(bool* aHasBattery) override;
+  NS_IMETHOD GetCleartypeParameters(nsAString& aCleartypeParams) override;
+  NS_IMETHOD GetWindowProtocol(nsAString& aWindowProtocol) override;
+  NS_IMETHOD GetDesktopEnvironment(nsAString& aDesktopEnvironment) override;
+  NS_IMETHOD GetTestType(nsAString& aTestType) override;
+  NS_IMETHOD GetAdapterDescription(nsAString& aAdapterDescription) override;
+  NS_IMETHOD GetAdapterDriver(nsAString& aAdapterDriver) override;
+  NS_IMETHOD GetAdapterVendorID(nsAString& aAdapterVendorID) override;
+  NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override;
+  NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override;
+  NS_IMETHOD GetAdapterRAM(uint32_t* aAdapterRAM) override;
+  NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override;
+  NS_IMETHOD GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) override;
+  NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override;
+  NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override;
+  NS_IMETHOD GetAdapterDriver2(nsAString& aAdapterDriver) override;
+  NS_IMETHOD GetAdapterVendorID2(nsAString& aAdapterVendorID) override;
+  NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override;
+  NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override;
+  NS_IMETHOD GetAdapterRAM2(uint32_t* aAdapterRAM) override;
+  NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override;
+  NS_IMETHOD GetAdapterDriverVersion2(
+      nsAString& aAdapterDriverVersion) override;
+  NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override;
+  NS_IMETHOD GetIsGPU2Active(bool* aIsGPU2Active) override;
+  NS_IMETHOD GetDrmRenderDevice(nsACString& aDrmRenderDevice) override;
+  using GfxInfoBase::GetFeatureStatus;
+  using GfxInfoBase::GetFeatureSuggestedDriverVersion;
+
+  virtual nsresult Init() override;
+
+  NS_IMETHOD_(void) GetData() override;
+
+#ifdef DEBUG
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIGFXINFODEBUG
+#endif
+
+ protected:
+  ~GfxInfo() = default;
+
+  OperatingSystem GetOperatingSystem() override {
+    return OperatingSystem::Linux;
+  }
+  virtual nsresult GetFeatureStatusImpl(
+      int32_t aFeature, int32_t* aStatus, nsAString& aSuggestedDriverVersion,
+      const nsTArray<GfxDriverInfo>& aDriverInfo, nsACString& aFailureId,
+      OperatingSystem* aOS = nullptr) override;
+  virtual const nsTArray<GfxDriverInfo>& GetGfxDriverInfo() override;
+
+  virtual bool DoesWindowProtocolMatch(
+      const nsAString& aBlocklistWindowProtocol,
+      const nsAString& aWindowProtocol) override;
+
+  virtual bool DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
+                                     const nsAString& aDriverVendor) override;
+
+ private:
+  nsCString mVendorId;
+  nsCString mDeviceId;
+  nsCString mDriverVendor;
+  nsCString mDriverVersion;
+  nsCString mAdapterDescription;
+  uint32_t mAdapterRAM;
+  nsCString mOS;
+  nsCString mOSRelease;
+  nsCString mTestType;
+
+  nsCString mSecondaryVendorId;
+  nsCString mSecondaryDeviceId;
+
+  nsCString mDrmRenderDevice;
+
+  nsTArray<nsCString> mDdxDrivers;
+
+  struct ScreenInfo {
+    uint32_t mWidth;
+    uint32_t mHeight;
+    bool mIsDefault;
+  };
+
+  nsTArray<ScreenInfo> mScreenInfo;
+  bool mHasTextureFromPixmap;
+  unsigned int mGLMajorVersion, mGLMinorVersion;
+  bool mIsMesa;
+  bool mIsAccelerated;
+  bool mIsWayland;
+  bool mIsXWayland;
+  bool mHasMultipleGPUs;
+  bool mGlxTestError;
+  bool mIsVAAPISupported;
+
+  void AddCrashReportAnnotations();
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif /* WIDGET_GTK_GFXINFO_h__ */
diff --git a/widget/gtk/GtkCompositorWidget.cpp b/widget/gtk/GtkCompositorWidget.cpp
new file mode 100644
index 0000000000..3a2dd3233c
--- /dev/null
+++ b/widget/gtk/GtkCompositorWidget.cpp
@@ -0,0 +1,246 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "GtkCompositorWidget.h"
+
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/widget/InProcessCompositorWidget.h"
+#include "mozilla/widget/PlatformWidgetTypes.h"
+#include "nsWindow.h"
+
+#ifdef MOZ_X11
+#  include "mozilla/X11Util.h"
+#endif
+
+#ifdef MOZ_WAYLAND
+#  include "mozilla/layers/NativeLayerWayland.h"
+#endif
+
+#ifdef MOZ_LOGGING
+#  undef LOG
+#  define LOG(str, ...)                               \
+    MOZ_LOG(IsPopup() ? gWidgetPopupLog : gWidgetLog, \
+            mozilla::LogLevel::Debug,                 \
+            ("[%p]: " str, mWidget.get(), ##__VA_ARGS__))
+#endif /* MOZ_LOGGING */
+
+namespace mozilla {
+namespace widget {
+
+GtkCompositorWidget::GtkCompositorWidget(
+    const GtkCompositorWidgetInitData& aInitData,
+    const layers::CompositorOptions& aOptions, RefPtr<nsWindow> aWindow)
+    : CompositorWidget(aOptions),
+      mWidget(std::move(aWindow)),
+      mClientSize(LayoutDeviceIntSize(aInitData.InitialClientSize()),
+                  "GtkCompositorWidget::mClientSize") {
+#if defined(MOZ_X11)
+  if (GdkIsX11Display()) {
+    mXWindow = (Window)aInitData.XWindow();
+    ConfigureX11Backend(mXWindow, aInitData.Shaped());
+    LOG("GtkCompositorWidget::GtkCompositorWidget() [%p] mXWindow %p "
+        "mIsRenderingSuspended %d\n",
+        (void*)mWidget.get(), (void*)mXWindow, !!mIsRenderingSuspended);
+  }
+#endif
+#if defined(MOZ_WAYLAND)
+  if (GdkIsWaylandDisplay()) {
+    ConfigureWaylandBackend(mWidget);
+    LOG("GtkCompositorWidget::GtkCompositorWidget() [%p] mWidget %p "
+        "mIsRenderingSuspended %d\n",
+        (void*)mWidget.get(), (void*)mWidget, !!mIsRenderingSuspended);
+  }
+#endif
+}
+
+GtkCompositorWidget::~GtkCompositorWidget() {
+  LOG("GtkCompositorWidget::~GtkCompositorWidget [%p]\n", (void*)mWidget.get());
+  DisableRendering();
+  RefPtr<nsIWidget> widget = mWidget.forget();
+  NS_ReleaseOnMainThread("GtkCompositorWidget::mWidget", widget.forget());
+}
+
+already_AddRefed<gfx::DrawTarget> GtkCompositorWidget::StartRemoteDrawing() {
+  return nullptr;
+}
+void GtkCompositorWidget::EndRemoteDrawing() {}
+
+already_AddRefed<gfx::DrawTarget>
+GtkCompositorWidget::StartRemoteDrawingInRegion(
+    const LayoutDeviceIntRegion& aInvalidRegion,
+    layers::BufferMode* aBufferMode) {
+  return mProvider.StartRemoteDrawingInRegion(aInvalidRegion, aBufferMode);
+}
+
+void GtkCompositorWidget::EndRemoteDrawingInRegion(
+    gfx::DrawTarget* aDrawTarget, const LayoutDeviceIntRegion& aInvalidRegion) {
+  mProvider.EndRemoteDrawingInRegion(aDrawTarget, aInvalidRegion);
+}
+
+nsIWidget* GtkCompositorWidget::RealWidget() { return mWidget; }
+
+void GtkCompositorWidget::NotifyClientSizeChanged(
+    const LayoutDeviceIntSize& aClientSize) {
+  LOG("GtkCompositorWidget::NotifyClientSizeChanged() to %d x %d",
+      aClientSize.width, aClientSize.height);
+
+  auto size = mClientSize.Lock();
+  *size = aClientSize;
+}
+
+LayoutDeviceIntSize GtkCompositorWidget::GetClientSize() {
+  auto size = mClientSize.Lock();
+  return *size;
+}
+
+void GtkCompositorWidget::RemoteLayoutSizeUpdated(
+    const LayoutDeviceRect& aSize) {
+  if (!mWidget || !mWidget->IsWaitingForCompositorResume()) {
+    return;
+  }
+
+  LOG("GtkCompositorWidget::RemoteLayoutSizeUpdated() %d x %d",
+      (int)aSize.width, (int)aSize.height);
+
+  // We're waiting for layout to match widget size.
+  auto clientSize = mClientSize.Lock();
+  if (clientSize->width != (int)aSize.width ||
+      clientSize->height != (int)aSize.height) {
+    LOG("quit, client size doesn't match (%d x %d)", clientSize->width,
+        clientSize->height);
+    return;
+  }
+
+  mWidget->ResumeCompositorFromCompositorThread();
+}
+
+EGLNativeWindowType GtkCompositorWidget::GetEGLNativeWindow() {
+  EGLNativeWindowType window = nullptr;
+  if (mWidget) {
+    window = (EGLNativeWindowType)mWidget->GetNativeData(NS_NATIVE_EGL_WINDOW);
+  }
+#if defined(MOZ_X11)
+  if (mXWindow) {
+    window = (EGLNativeWindowType)mXWindow;
+  }
+#endif
+  LOG("GtkCompositorWidget::GetEGLNativeWindow [%p] window %p\n", mWidget.get(),
+      window);
+  return window;
+}
+
+#if defined(MOZ_WAYLAND)
+void GtkCompositorWidget::SetEGLNativeWindowSize(
+    const LayoutDeviceIntSize& aEGLWindowSize) {
+  if (mWidget) {
+    mWidget->SetEGLNativeWindowSize(aEGLWindowSize);
+  }
+}
+#endif
+
+LayoutDeviceIntRegion GtkCompositorWidget::GetTransparentRegion() {
+  // We need to clear target buffer alpha values of popup windows as
+  // SW-WR paints with alpha blending (see Bug 1674473).
+  if (!mWidget || mWidget->IsPopup()) {
+    return LayoutDeviceIntRect(LayoutDeviceIntPoint(0, 0), GetClientSize());
+  }
+
+  // Clear background of titlebar area to render titlebar
+  // transparent corners correctly.
+  return mWidget->GetTitlebarRect();
+}
+
+#ifdef MOZ_WAYLAND
+RefPtr<mozilla::layers::NativeLayerRoot>
+GtkCompositorWidget::GetNativeLayerRoot() {
+  if (gfx::gfxVars::UseWebRenderCompositor()) {
+    if (!mNativeLayerRoot) {
+      MOZ_ASSERT(mWidget && mWidget->GetMozContainer());
+      mNativeLayerRoot = NativeLayerRootWayland::CreateForMozContainer(
+          mWidget->GetMozContainer());
+    }
+    return mNativeLayerRoot;
+  }
+  return nullptr;
+}
+#endif
+
+void GtkCompositorWidget::DisableRendering() {
+  LOG("GtkCompositorWidget::DisableRendering [%p]\n", (void*)mWidget.get());
+  mIsRenderingSuspended = true;
+  mProvider.CleanupResources();
+#if defined(MOZ_X11)
+  mXWindow = {};
+#endif
+}
+
+#if defined(MOZ_WAYLAND)
+bool GtkCompositorWidget::ConfigureWaylandBackend(RefPtr<nsWindow> aWindow) {
+  mProvider.Initialize(aWindow);
+  return true;
+}
+#endif
+
+#if defined(MOZ_X11)
+bool GtkCompositorWidget::ConfigureX11Backend(Window aXWindow, bool aShaped) {
+  mXWindow = aXWindow;
+
+  // We don't have X window yet.
+  if (!mXWindow) {
+    mIsRenderingSuspended = true;
+    return false;
+  }
+
+  // Grab the window's visual and depth
+  XWindowAttributes windowAttrs;
+  if (!XGetWindowAttributes(DefaultXDisplay(), mXWindow, &windowAttrs)) {
+    NS_WARNING("GtkCompositorWidget(): XGetWindowAttributes() failed!");
+    return false;
+  }
+
+  Visual* visual = windowAttrs.visual;
+  int depth = windowAttrs.depth;
+
+  // Initialize the window surface provider
+  mProvider.Initialize(mXWindow, visual, depth, aShaped);
+  return true;
+}
+#endif
+
+void GtkCompositorWidget::EnableRendering(const uintptr_t aXWindow,
+                                          const bool aShaped) {
+  LOG("GtkCompositorWidget::EnableRendering() [%p]\n", mWidget.get());
+
+  if (!mIsRenderingSuspended) {
+    LOG("  quit, mIsRenderingSuspended = false\n");
+    return;
+  }
+#if defined(MOZ_WAYLAND)
+  if (GdkIsWaylandDisplay()) {
+    LOG("  configure widget %p\n", mWidget.get());
+    if (!ConfigureWaylandBackend(mWidget)) {
+      return;
+    }
+  }
+#endif
+#if defined(MOZ_X11)
+  if (GdkIsX11Display()) {
+    LOG("  configure XWindow %p shaped %d\n", (void*)aXWindow, aShaped);
+    if (!ConfigureX11Backend((Window)aXWindow, aShaped)) {
+      return;
+    }
+  }
+#endif
+  mIsRenderingSuspended = false;
+}
+#ifdef MOZ_LOGGING
+bool GtkCompositorWidget::IsPopup() {
+  return mWidget ? mWidget->IsPopup() : false;
+}
+#endif
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/GtkCompositorWidget.h b/widget/gtk/GtkCompositorWidget.h
new file mode 100644
index 0000000000..bc1c3379cd
--- /dev/null
+++ b/widget/gtk/GtkCompositorWidget.h
@@ -0,0 +1,137 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef widget_gtk_GtkCompositorWidget_h
+#define widget_gtk_GtkCompositorWidget_h
+
+#include "GLDefs.h"
+#include "mozilla/DataMutex.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "WindowSurfaceProvider.h"
+
+class nsIWidget;
+class nsWindow;
+
+namespace mozilla {
+
+namespace layers {
+class NativeLayerRootWayland;
+}  // namespace layers
+
+namespace widget {
+
+class PlatformCompositorWidgetDelegate : public CompositorWidgetDelegate {
+ public:
+  virtual void NotifyClientSizeChanged(
+      const LayoutDeviceIntSize& aClientSize) = 0;
+  virtual GtkCompositorWidget* AsGtkCompositorWidget() { return nullptr; };
+
+  virtual void DisableRendering() = 0;
+  virtual void EnableRendering(const uintptr_t aXWindow,
+                               const bool aShaped) = 0;
+
+  // CompositorWidgetDelegate Overrides
+
+  PlatformCompositorWidgetDelegate* AsPlatformSpecificDelegate() override {
+    return this;
+  }
+};
+
+class GtkCompositorWidgetInitData;
+
+class GtkCompositorWidget : public CompositorWidget,
+                            public PlatformCompositorWidgetDelegate {
+ public:
+  GtkCompositorWidget(const GtkCompositorWidgetInitData& aInitData,
+                      const layers::CompositorOptions& aOptions,
+                      RefPtr<nsWindow> aWindow /* = nullptr*/);
+  ~GtkCompositorWidget();
+
+  // CompositorWidget Overrides
+
+  already_AddRefed<gfx::DrawTarget> StartRemoteDrawing() override;
+  void EndRemoteDrawing() override;
+
+  already_AddRefed<gfx::DrawTarget> StartRemoteDrawingInRegion(
+      const LayoutDeviceIntRegion& aInvalidRegion,
+      layers::BufferMode* aBufferMode) override;
+  void EndRemoteDrawingInRegion(
+      gfx::DrawTarget* aDrawTarget,
+      const LayoutDeviceIntRegion& aInvalidRegion) override;
+
+  LayoutDeviceIntSize GetClientSize() override;
+  void RemoteLayoutSizeUpdated(const LayoutDeviceRect& aSize);
+
+  nsIWidget* RealWidget() override;
+  GtkCompositorWidget* AsGTK() override { return this; }
+  CompositorWidgetDelegate* AsDelegate() override { return this; }
+
+  EGLNativeWindowType GetEGLNativeWindow();
+
+  LayoutDeviceIntRegion GetTransparentRegion() override;
+
+  // Suspend rendering of this remote widget and clear all resources.
+  // Can be used when underlying window is hidden/unmapped.
+  void DisableRendering() override;
+
+  // Resume rendering with to given aXWindow (X11) or nsWindow (Wayland).
+  void EnableRendering(const uintptr_t aXWindow, const bool aShaped) override;
+
+#if defined(MOZ_X11)
+  Window XWindow() const { return mXWindow; }
+#endif
+#if defined(MOZ_WAYLAND)
+  void SetEGLNativeWindowSize(const LayoutDeviceIntSize& aEGLWindowSize);
+  RefPtr<mozilla::layers::NativeLayerRoot> GetNativeLayerRoot() override;
+#endif
+
+  bool PreRender(WidgetRenderingContext* aContext) override {
+    return !mIsRenderingSuspended;
+  }
+  bool IsHidden() const override { return mIsRenderingSuspended; }
+
+  // PlatformCompositorWidgetDelegate Overrides
+
+  void NotifyClientSizeChanged(const LayoutDeviceIntSize& aClientSize) override;
+  GtkCompositorWidget* AsGtkCompositorWidget() override { return this; }
+
+ private:
+#if defined(MOZ_WAYLAND)
+  bool ConfigureWaylandBackend(RefPtr<nsWindow> aWindow);
+#endif
+#if defined(MOZ_X11)
+  bool ConfigureX11Backend(Window aXWindow, bool aShaped);
+#endif
+#ifdef MOZ_LOGGING
+  bool IsPopup();
+#endif
+
+ protected:
+  RefPtr<nsWindow> mWidget;
+
+ private:
+  // This field is written to on the main thread and read from on the compositor
+  // or renderer thread. During window resizing, this is subject to a (largely
+  // benign) read/write race, see bug 1665726. The DataMutex doesn't prevent the
+  // read/write race, but it does make it Not Undefined Behaviour, and also
+  // ensures we only ever use the old or new size, and not some weird synthesis
+  // of the two.
+  DataMutex<LayoutDeviceIntSize> mClientSize;
+
+  WindowSurfaceProvider mProvider;
+
+#if defined(MOZ_X11)
+  Window mXWindow = {};
+#endif
+#ifdef MOZ_WAYLAND
+  RefPtr<mozilla::layers::NativeLayerRootWayland> mNativeLayerRoot;
+#endif
+  Atomic<bool> mIsRenderingSuspended{true};
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // widget_gtk_GtkCompositorWidget_h
diff --git a/widget/gtk/IMContextWrapper.cpp b/widget/gtk/IMContextWrapper.cpp
new file mode 100644
index 0000000000..25dfeb7c48
--- /dev/null
+++ b/widget/gtk/IMContextWrapper.cpp
@@ -0,0 +1,3288 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Logging.h"
+#include "nsString.h"
+#include "prtime.h"
+#include "prenv.h"
+
+#include "IMContextWrapper.h"
+#include "nsGtkKeyUtils.h"
+#include "nsWindow.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/Likely.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticPrefs_intl.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TextEventDispatcher.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/ToString.h"
+#include "mozilla/WritingModes.h"
+
+// For collecting other people's log, tell `MOZ_LOG=IMEHandler:4,sync`
+// rather than `MOZ_LOG=IMEHandler:5,sync` since using `5` may create too
+// big file.
+// Therefore you shouldn't use `LogLevel::Verbose` for logging usual behavior.
+mozilla::LazyLogModule gIMELog("IMEHandler");
+
+namespace mozilla {
+namespace widget {
+
+static inline const char* ToChar(bool aBool) {
+  return aBool ? "true" : "false";
+}
+
+static const char* GetEventType(GdkEventKey* aKeyEvent) {
+  switch (aKeyEvent->type) {
+    case GDK_KEY_PRESS:
+      return "GDK_KEY_PRESS";
+    case GDK_KEY_RELEASE:
+      return "GDK_KEY_RELEASE";
+    default:
+      return "Unknown";
+  }
+}
+
+class GetEventStateName : public nsAutoCString {
+ public:
+  explicit GetEventStateName(guint aState,
+                             IMContextWrapper::IMContextID aIMContextID =
+                                 IMContextWrapper::IMContextID::Unknown) {
+    if (aState & GDK_SHIFT_MASK) {
+      AppendModifier("shift");
+    }
+    if (aState & GDK_CONTROL_MASK) {
+      AppendModifier("control");
+    }
+    if (aState & GDK_MOD1_MASK) {
+      AppendModifier("mod1");
+    }
+    if (aState & GDK_MOD2_MASK) {
+      AppendModifier("mod2");
+    }
+    if (aState & GDK_MOD3_MASK) {
+      AppendModifier("mod3");
+    }
+    if (aState & GDK_MOD4_MASK) {
+      AppendModifier("mod4");
+    }
+    if (aState & GDK_MOD4_MASK) {
+      AppendModifier("mod5");
+    }
+    if (aState & GDK_MOD4_MASK) {
+      AppendModifier("mod5");
+    }
+    switch (aIMContextID) {
+      case IMContextWrapper::IMContextID::IBus:
+        static const guint IBUS_HANDLED_MASK = 1 << 24;
+        static const guint IBUS_IGNORED_MASK = 1 << 25;
+        if (aState & IBUS_HANDLED_MASK) {
+          AppendModifier("IBUS_HANDLED_MASK");
+        }
+        if (aState & IBUS_IGNORED_MASK) {
+          AppendModifier("IBUS_IGNORED_MASK");
+        }
+        break;
+      case IMContextWrapper::IMContextID::Fcitx:
+      case IMContextWrapper::IMContextID::Fcitx5:
+        static const guint FcitxKeyState_HandledMask = 1 << 24;
+        static const guint FcitxKeyState_IgnoredMask = 1 << 25;
+        if (aState & FcitxKeyState_HandledMask) {
+          AppendModifier("FcitxKeyState_HandledMask");
+        }
+        if (aState & FcitxKeyState_IgnoredMask) {
+          AppendModifier("FcitxKeyState_IgnoredMask");
+        }
+        break;
+      default:
+        break;
+    }
+  }
+
+ private:
+  void AppendModifier(const char* aModifierName) {
+    if (!IsEmpty()) {
+      AppendLiteral(" + ");
+    }
+    Append(aModifierName);
+  }
+};
+
+class GetTextRangeStyleText final : public nsAutoCString {
+ public:
+  explicit GetTextRangeStyleText(const TextRangeStyle& aStyle) {
+    if (!aStyle.IsDefined()) {
+      AssignLiteral("{ IsDefined()=false }");
+      return;
+    }
+
+    if (aStyle.IsLineStyleDefined()) {
+      AppendLiteral("{ mLineStyle=");
+      AppendLineStyle(aStyle.mLineStyle);
+      if (aStyle.IsUnderlineColorDefined()) {
+        AppendLiteral(", mUnderlineColor=");
+        AppendColor(aStyle.mUnderlineColor);
+      } else {
+        AppendLiteral(", IsUnderlineColorDefined=false");
+      }
+    } else {
+      AppendLiteral("{ IsLineStyleDefined()=false");
+    }
+
+    if (aStyle.IsForegroundColorDefined()) {
+      AppendLiteral(", mForegroundColor=");
+      AppendColor(aStyle.mForegroundColor);
+    } else {
+      AppendLiteral(", IsForegroundColorDefined()=false");
+    }
+
+    if (aStyle.IsBackgroundColorDefined()) {
+      AppendLiteral(", mBackgroundColor=");
+      AppendColor(aStyle.mBackgroundColor);
+    } else {
+      AppendLiteral(", IsBackgroundColorDefined()=false");
+    }
+
+    AppendLiteral(" }");
+  }
+  void AppendLineStyle(TextRangeStyle::LineStyle aLineStyle) {
+    switch (aLineStyle) {
+      case TextRangeStyle::LineStyle::None:
+        AppendLiteral("LineStyle::None");
+        break;
+      case TextRangeStyle::LineStyle::Solid:
+        AppendLiteral("LineStyle::Solid");
+        break;
+      case TextRangeStyle::LineStyle::Dotted:
+        AppendLiteral("LineStyle::Dotted");
+        break;
+      case TextRangeStyle::LineStyle::Dashed:
+        AppendLiteral("LineStyle::Dashed");
+        break;
+      case TextRangeStyle::LineStyle::Double:
+        AppendLiteral("LineStyle::Double");
+        break;
+      case TextRangeStyle::LineStyle::Wavy:
+        AppendLiteral("LineStyle::Wavy");
+        break;
+      default:
+        AppendPrintf("Invalid(0x%02X)",
+                     static_cast<TextRangeStyle::LineStyleType>(aLineStyle));
+        break;
+    }
+  }
+  void AppendColor(nscolor aColor) {
+    AppendPrintf("{ R=0x%02X, G=0x%02X, B=0x%02X, A=0x%02X }", NS_GET_R(aColor),
+                 NS_GET_G(aColor), NS_GET_B(aColor), NS_GET_A(aColor));
+  }
+  virtual ~GetTextRangeStyleText() = default;
+};
+
+const static bool kUseSimpleContextDefault = false;
+
+/******************************************************************************
+ * SelectionStyleProvider
+ *
+ * IME (e.g., fcitx, ~4.2.8.3) may look up selection colors of widget, which
+ * is related to the window associated with the IM context, to support any
+ * colored widgets.  Our editor (like <input type="text">) is rendered as
+ * native GtkTextView as far as possible by default and if editor color is
+ * changed by web apps, nsTextFrame may swap background color of foreground
+ * color of composition string for making composition string is always
+ * visually distinct in normal text.
+ *
+ * So, we would like IME to set style of composition string to good colors
+ * in GtkTextView.  Therefore, this class overwrites selection colors of
+ * our widget with selection colors of GtkTextView so that it's possible IME
+ * to refer selection colors of GtkTextView via our widget.
+ ******************************************************************************/
+
+static Maybe<nscolor> GetSystemColor(LookAndFeel::ColorID aId) {
+  return LookAndFeel::GetColor(aId, LookAndFeel::ColorScheme::Light,
+                               LookAndFeel::UseStandins::No);
+}
+
+class SelectionStyleProvider final {
+ public:
+  static SelectionStyleProvider* GetExistingInstance() { return sInstance; }
+
+  static SelectionStyleProvider* GetInstance() {
+    if (sHasShutDown) {
+      return nullptr;
+    }
+    if (!sInstance) {
+      sInstance = new SelectionStyleProvider();
+    }
+    return sInstance;
+  }
+
+  static void Shutdown() {
+    if (sInstance) {
+      g_object_unref(sInstance->mProvider);
+    }
+    delete sInstance;
+    sInstance = nullptr;
+    sHasShutDown = true;
+  }
+
+  // aGDKWindow is a GTK window which will be associated with an IM context.
+  void AttachTo(GdkWindow* aGDKWindow) {
+    GtkWidget* widget = nullptr;
+    // gdk_window_get_user_data() typically returns pointer to widget that
+    // window belongs to.  If it's widget, fcitx retrieves selection colors
+    // of them.  So, we need to overwrite its style.
+    gdk_window_get_user_data(aGDKWindow, (gpointer*)&widget);
+    if (GTK_IS_WIDGET(widget)) {
+      gtk_style_context_add_provider(gtk_widget_get_style_context(widget),
+                                     GTK_STYLE_PROVIDER(mProvider),
+                                     GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+    }
+  }
+
+  void OnThemeChanged() {
+    // fcitx refers GtkStyle::text[GTK_STATE_SELECTED] and
+    // GtkStyle::bg[GTK_STATE_SELECTED] (although pair of text and *base*
+    // or *fg* and bg is correct).  gtk_style_update_from_context() will
+    // set these colors using the widget's GtkStyleContext and so the
+    // colors can be controlled by a ":selected" CSS rule.
+    nsAutoCString style(":selected{");
+    // FYI: LookAndFeel always returns selection colors of GtkTextView.
+    if (auto selectionForegroundColor =
+            GetSystemColor(LookAndFeel::ColorID::Highlight)) {
+      double alpha =
+          static_cast<double>(NS_GET_A(*selectionForegroundColor)) / 0xFF;
+      style.AppendPrintf("color:rgba(%u,%u,%u,",
+                         NS_GET_R(*selectionForegroundColor),
+                         NS_GET_G(*selectionForegroundColor),
+                         NS_GET_B(*selectionForegroundColor));
+      // We can't use AppendPrintf here, because it does locale-specific
+      // formatting of floating-point values.
+      style.AppendFloat(alpha);
+      style.AppendPrintf(");");
+    }
+    if (auto selectionBackgroundColor =
+            GetSystemColor(LookAndFeel::ColorID::Highlighttext)) {
+      double alpha =
+          static_cast<double>(NS_GET_A(*selectionBackgroundColor)) / 0xFF;
+      style.AppendPrintf("background-color:rgba(%u,%u,%u,",
+                         NS_GET_R(*selectionBackgroundColor),
+                         NS_GET_G(*selectionBackgroundColor),
+                         NS_GET_B(*selectionBackgroundColor));
+      style.AppendFloat(alpha);
+      style.AppendPrintf(");");
+    }
+    style.AppendLiteral("}");
+    gtk_css_provider_load_from_data(mProvider, style.get(), -1, nullptr);
+  }
+
+ private:
+  static SelectionStyleProvider* sInstance;
+  static bool sHasShutDown;
+  GtkCssProvider* const mProvider;
+
+  SelectionStyleProvider() : mProvider(gtk_css_provider_new()) {
+    OnThemeChanged();
+  }
+};
+
+SelectionStyleProvider* SelectionStyleProvider::sInstance = nullptr;
+bool SelectionStyleProvider::sHasShutDown = false;
+
+/******************************************************************************
+ * IMContextWrapper
+ ******************************************************************************/
+
+IMContextWrapper* IMContextWrapper::sLastFocusedContext = nullptr;
+guint16 IMContextWrapper::sWaitingSynthesizedKeyPressHardwareKeyCode = 0;
+bool IMContextWrapper::sUseSimpleContext;
+
+NS_IMPL_ISUPPORTS(IMContextWrapper, TextEventDispatcherListener,
+                  nsISupportsWeakReference)
+
+IMContextWrapper::IMContextWrapper(nsWindow* aOwnerWindow)
+    : mOwnerWindow(aOwnerWindow),
+      mLastFocusedWindow(nullptr),
+      mContext(nullptr),
+      mSimpleContext(nullptr),
+      mDummyContext(nullptr),
+      mComposingContext(nullptr),
+      mCompositionStart(UINT32_MAX),
+      mProcessingKeyEvent(nullptr),
+      mCompositionState(eCompositionState_NotComposing),
+      mIMContextID(IMContextID::Unknown),
+      mFallbackToKeyEvent(false),
+      mKeyboardEventWasDispatched(false),
+      mKeyboardEventWasConsumed(false),
+      mIsDeletingSurrounding(false),
+      mLayoutChanged(false),
+      mSetCursorPositionOnKeyEvent(true),
+      mPendingResettingIMContext(false),
+      mRetrieveSurroundingSignalReceived(false),
+      mMaybeInDeadKeySequence(false),
+      mIsIMInAsyncKeyHandlingMode(false),
+      mSetInputPurposeAndInputHints(false) {
+  static bool sFirstInstance = true;
+  if (sFirstInstance) {
+    sFirstInstance = false;
+    sUseSimpleContext =
+        Preferences::GetBool("intl.ime.use_simple_context_on_password_field",
+                             kUseSimpleContextDefault);
+  }
+  Init();
+}
+
+static bool IsIBusInSyncMode() {
+  // See ibus_im_context_class_init() in client/gtk2/ibusimcontext.c
+  // https://github.com/ibus/ibus/blob/86963f2f94d1e4fc213b01c2bc2ba9dcf4b22219/client/gtk2/ibusimcontext.c#L610
+  const char* env = PR_GetEnv("IBUS_ENABLE_SYNC_MODE");
+
+  // See _get_boolean_env() in client/gtk2/ibusimcontext.c
+  // https://github.com/ibus/ibus/blob/86963f2f94d1e4fc213b01c2bc2ba9dcf4b22219/client/gtk2/ibusimcontext.c#L520-L537
+  if (!env) {
+    return false;
+  }
+  nsDependentCString envStr(env);
+  if (envStr.IsEmpty() || envStr.EqualsLiteral("0") ||
+      envStr.EqualsLiteral("false") || envStr.EqualsLiteral("False") ||
+      envStr.EqualsLiteral("FALSE")) {
+    return false;
+  }
+  return true;
+}
+
+static bool GetFcitxBoolEnv(const char* aEnv) {
+  // See fcitx_utils_get_boolean_env in src/lib/fcitx-utils/utils.c
+  // https://github.com/fcitx/fcitx/blob/0c87840dc7d9460c2cb5feaeefec299d0d3d62ec/src/lib/fcitx-utils/utils.c#L721-L736
+  const char* env = PR_GetEnv(aEnv);
+  if (!env) {
+    return false;
+  }
+  nsDependentCString envStr(env);
+  if (envStr.IsEmpty() || envStr.EqualsLiteral("0") ||
+      envStr.EqualsLiteral("false")) {
+    return false;
+  }
+  return true;
+}
+
+static bool IsFcitxInSyncMode() {
+  // See fcitx_im_context_class_init() in src/frontend/gtk2/fcitximcontext.c
+  // https://github.com/fcitx/fcitx/blob/78b98d9230dc9630e99d52e3172bdf440ffd08c4/src/frontend/gtk2/fcitximcontext.c#L395-L398
+  return GetFcitxBoolEnv("IBUS_ENABLE_SYNC_MODE") ||
+         GetFcitxBoolEnv("FCITX_ENABLE_SYNC_MODE");
+}
+
+nsDependentCSubstring IMContextWrapper::GetIMName() const {
+  const char* contextIDChar =
+      gtk_im_multicontext_get_context_id(GTK_IM_MULTICONTEXT(mContext));
+  if (!contextIDChar) {
+    return nsDependentCSubstring();
+  }
+
+  nsDependentCSubstring im(contextIDChar, strlen(contextIDChar));
+
+  // If the context is XIM, actual engine must be specified with
+  // |XMODIFIERS=@im=foo|.
+  const char* xmodifiersChar = PR_GetEnv("XMODIFIERS");
+  if (!xmodifiersChar || !im.EqualsLiteral("xim")) {
+    return im;
+  }
+
+  nsDependentCString xmodifiers(xmodifiersChar);
+  int32_t atIMValueStart = xmodifiers.Find("@im=") + 4;
+  if (atIMValueStart < 4 ||
+      xmodifiers.Length() <= static_cast<size_t>(atIMValueStart)) {
+    return im;
+  }
+
+  int32_t atIMValueEnd = xmodifiers.Find("@", atIMValueStart);
+  if (atIMValueEnd > atIMValueStart) {
+    return nsDependentCSubstring(xmodifiersChar + atIMValueStart,
+                                 atIMValueEnd - atIMValueStart);
+  }
+
+  if (atIMValueEnd == kNotFound) {
+    return nsDependentCSubstring(xmodifiersChar + atIMValueStart,
+                                 strlen(xmodifiersChar) - atIMValueStart);
+  }
+
+  return im;
+}
+
+void IMContextWrapper::Init() {
+  MozContainer* container = mOwnerWindow->GetMozContainer();
+  MOZ_ASSERT(container, "container is null");
+  GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(container));
+
+  // Overwrite selection colors of the window before associating the window
+  // with IM context since IME may look up selection colors via IM context
+  // to support any colored widgets.
+  SelectionStyleProvider::GetInstance()->AttachTo(gdkWindow);
+
+  // NOTE: gtk_im_*_new() abort (kill) the whole process when it fails.
+  //       So, we don't need to check the result.
+
+  // Normal context.
+  mContext = gtk_im_multicontext_new();
+  gtk_im_context_set_client_window(mContext, gdkWindow);
+  g_signal_connect(mContext, "preedit_changed",
+                   G_CALLBACK(IMContextWrapper::OnChangeCompositionCallback),
+                   this);
+  g_signal_connect(mContext, "retrieve_surrounding",
+                   G_CALLBACK(IMContextWrapper::OnRetrieveSurroundingCallback),
+                   this);
+  g_signal_connect(mContext, "delete_surrounding",
+                   G_CALLBACK(IMContextWrapper::OnDeleteSurroundingCallback),
+                   this);
+  g_signal_connect(mContext, "commit",
+                   G_CALLBACK(IMContextWrapper::OnCommitCompositionCallback),
+                   this);
+  g_signal_connect(mContext, "preedit_start",
+                   G_CALLBACK(IMContextWrapper::OnStartCompositionCallback),
+                   this);
+  g_signal_connect(mContext, "preedit_end",
+                   G_CALLBACK(IMContextWrapper::OnEndCompositionCallback),
+                   this);
+  nsDependentCSubstring im = GetIMName();
+  if (im.EqualsLiteral("ibus")) {
+    mIMContextID = IMContextID::IBus;
+    mIsIMInAsyncKeyHandlingMode = !IsIBusInSyncMode();
+    // Although ibus has key snooper mode, it's forcibly disabled on Firefox
+    // in default settings by its whitelist since we always send key events
+    // to IME before handling shortcut keys.  The whitelist can be
+    // customized with env, IBUS_NO_SNOOPER_APPS, but we don't need to
+    // support such rare cases for reducing maintenance cost.
+    mIsKeySnooped = false;
+  } else if (im.EqualsLiteral("fcitx")) {
+    mIMContextID = IMContextID::Fcitx;
+    mIsIMInAsyncKeyHandlingMode = !IsFcitxInSyncMode();
+    // Although Fcitx has key snooper mode similar to ibus, it's also
+    // disabled on Firefox in default settings by its whitelist.  The
+    // whitelist can be customized with env, IBUS_NO_SNOOPER_APPS or
+    // FCITX_NO_SNOOPER_APPS, but we don't need to support such rare cases
+    // for reducing maintenance cost.
+    mIsKeySnooped = false;
+  } else if (im.EqualsLiteral("fcitx5")) {
+    mIMContextID = IMContextID::Fcitx5;
+    mIsIMInAsyncKeyHandlingMode = true;  // does not have sync mode.
+    mIsKeySnooped = false;               // never use key snooper.
+  } else if (im.EqualsLiteral("uim")) {
+    mIMContextID = IMContextID::Uim;
+    mIsIMInAsyncKeyHandlingMode = false;
+    // We cannot know if uim uses key snooper since it's build option of
+    // uim.  Therefore, we need to retrieve the consideration from the
+    // pref for making users and distributions allowed to choose their
+    // preferred value.
+    mIsKeySnooped =
+        Preferences::GetBool("intl.ime.hack.uim.using_key_snooper", true);
+  } else if (im.EqualsLiteral("scim")) {
+    mIMContextID = IMContextID::Scim;
+    mIsIMInAsyncKeyHandlingMode = false;
+    mIsKeySnooped = false;
+  } else if (im.EqualsLiteral("iiim")) {
+    mIMContextID = IMContextID::IIIMF;
+    mIsIMInAsyncKeyHandlingMode = false;
+    mIsKeySnooped = false;
+  } else if (im.EqualsLiteral("wayland")) {
+    mIMContextID = IMContextID::Wayland;
+    mIsIMInAsyncKeyHandlingMode = false;
+    mIsKeySnooped = true;
+  } else {
+    mIMContextID = IMContextID::Unknown;
+    mIsIMInAsyncKeyHandlingMode = false;
+    mIsKeySnooped = false;
+  }
+
+  // Simple context
+  if (sUseSimpleContext) {
+    mSimpleContext = gtk_im_context_simple_new();
+    gtk_im_context_set_client_window(mSimpleContext, gdkWindow);
+    g_signal_connect(mSimpleContext, "preedit_changed",
+                     G_CALLBACK(&IMContextWrapper::OnChangeCompositionCallback),
+                     this);
+    g_signal_connect(
+        mSimpleContext, "retrieve_surrounding",
+        G_CALLBACK(&IMContextWrapper::OnRetrieveSurroundingCallback), this);
+    g_signal_connect(mSimpleContext, "delete_surrounding",
+                     G_CALLBACK(&IMContextWrapper::OnDeleteSurroundingCallback),
+                     this);
+    g_signal_connect(mSimpleContext, "commit",
+                     G_CALLBACK(&IMContextWrapper::OnCommitCompositionCallback),
+                     this);
+    g_signal_connect(mSimpleContext, "preedit_start",
+                     G_CALLBACK(IMContextWrapper::OnStartCompositionCallback),
+                     this);
+    g_signal_connect(mSimpleContext, "preedit_end",
+                     G_CALLBACK(IMContextWrapper::OnEndCompositionCallback),
+                     this);
+  }
+
+  // Dummy context
+  mDummyContext = gtk_im_multicontext_new();
+  gtk_im_context_set_client_window(mDummyContext, gdkWindow);
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p Init(), mOwnerWindow=%p, mContext=%p (im=\"%s\"), "
+           "mIsIMInAsyncKeyHandlingMode=%s, mIsKeySnooped=%s, "
+           "mSimpleContext=%p, mDummyContext=%p, "
+           "gtk_im_multicontext_get_context_id()=\"%s\", "
+           "PR_GetEnv(\"XMODIFIERS\")=\"%s\"",
+           this, mOwnerWindow, mContext, nsAutoCString(im).get(),
+           ToChar(mIsIMInAsyncKeyHandlingMode), ToChar(mIsKeySnooped),
+           mSimpleContext, mDummyContext,
+           gtk_im_multicontext_get_context_id(GTK_IM_MULTICONTEXT(mContext)),
+           PR_GetEnv("XMODIFIERS")));
+}
+
+/* static */
+void IMContextWrapper::Shutdown() { SelectionStyleProvider::Shutdown(); }
+
+IMContextWrapper::~IMContextWrapper() {
+  if (this == sLastFocusedContext) {
+    sLastFocusedContext = nullptr;
+  }
+  MOZ_LOG(gIMELog, LogLevel::Info, ("0x%p ~IMContextWrapper()", this));
+}
+
+NS_IMETHODIMP
+IMContextWrapper::NotifyIME(TextEventDispatcher* aTextEventDispatcher,
+                            const IMENotification& aNotification) {
+  switch (aNotification.mMessage) {
+    case REQUEST_TO_COMMIT_COMPOSITION:
+    case REQUEST_TO_CANCEL_COMPOSITION: {
+      nsWindow* window =
+          static_cast<nsWindow*>(aTextEventDispatcher->GetWidget());
+      return IsComposing() ? EndIMEComposition(window) : NS_OK;
+    }
+    case NOTIFY_IME_OF_FOCUS:
+      OnFocusChangeInGecko(true);
+      return NS_OK;
+    case NOTIFY_IME_OF_BLUR:
+      OnFocusChangeInGecko(false);
+      return NS_OK;
+    case NOTIFY_IME_OF_POSITION_CHANGE:
+      OnLayoutChange();
+      return NS_OK;
+    case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED:
+      OnUpdateComposition();
+      return NS_OK;
+    case NOTIFY_IME_OF_SELECTION_CHANGE: {
+      nsWindow* window =
+          static_cast<nsWindow*>(aTextEventDispatcher->GetWidget());
+      OnSelectionChange(window, aNotification);
+      return NS_OK;
+    }
+    default:
+      return NS_ERROR_NOT_IMPLEMENTED;
+  }
+}
+
+NS_IMETHODIMP_(void)
+IMContextWrapper::OnRemovedFrom(TextEventDispatcher* aTextEventDispatcher) {
+  // XXX When input transaction is being stolen by add-on, what should we do?
+}
+
+NS_IMETHODIMP_(void)
+IMContextWrapper::WillDispatchKeyboardEvent(
+    TextEventDispatcher* aTextEventDispatcher,
+    WidgetKeyboardEvent& aKeyboardEvent, uint32_t aIndexOfKeypress,
+    void* aData) {
+  KeymapWrapper::WillDispatchKeyboardEvent(aKeyboardEvent,
+                                           static_cast<GdkEventKey*>(aData));
+}
+
+TextEventDispatcher* IMContextWrapper::GetTextEventDispatcher() {
+  if (NS_WARN_IF(!mLastFocusedWindow)) {
+    return nullptr;
+  }
+  TextEventDispatcher* dispatcher =
+      mLastFocusedWindow->GetTextEventDispatcher();
+  // nsIWidget::GetTextEventDispatcher() shouldn't return nullptr.
+  MOZ_RELEASE_ASSERT(dispatcher);
+  return dispatcher;
+}
+
+NS_IMETHODIMP_(IMENotificationRequests)
+IMContextWrapper::GetIMENotificationRequests() {
+  IMENotificationRequests::Notifications notifications =
+      IMENotificationRequests::NOTIFY_NOTHING;
+  // If it's not enabled, we don't need position change notification.
+  if (IsEnabled()) {
+    notifications |= IMENotificationRequests::NOTIFY_POSITION_CHANGE;
+  }
+  return IMENotificationRequests(notifications);
+}
+
+void IMContextWrapper::OnDestroyWindow(nsWindow* aWindow) {
+  MOZ_LOG(
+      gIMELog, LogLevel::Info,
+      ("0x%p OnDestroyWindow(aWindow=0x%p), mLastFocusedWindow=0x%p, "
+       "mOwnerWindow=0x%p, mLastFocusedModule=0x%p",
+       this, aWindow, mLastFocusedWindow, mOwnerWindow, sLastFocusedContext));
+
+  MOZ_ASSERT(aWindow, "aWindow must not be null");
+
+  if (mLastFocusedWindow == aWindow) {
+    if (IsComposing()) {
+      EndIMEComposition(aWindow);
+    }
+    NotifyIMEOfFocusChange(IMEFocusState::Blurred);
+    mLastFocusedWindow = nullptr;
+  }
+
+  if (mOwnerWindow != aWindow) {
+    return;
+  }
+
+  if (sLastFocusedContext == this) {
+    sLastFocusedContext = nullptr;
+  }
+
+  /**
+   * NOTE:
+   *   The given window is the owner of this, so, we must release the
+   *   contexts now.  But that might be referred from other nsWindows
+   *   (they are children of this.  But we don't know why there are the
+   *   cases).  So, we need to clear the pointers that refers to contexts
+   *   and this if the other referrers are still alive. See bug 349727.
+   */
+  if (mContext) {
+    PrepareToDestroyContext(mContext);
+    gtk_im_context_set_client_window(mContext, nullptr);
+    g_object_unref(mContext);
+    mContext = nullptr;
+  }
+
+  if (mSimpleContext) {
+    gtk_im_context_set_client_window(mSimpleContext, nullptr);
+    g_object_unref(mSimpleContext);
+    mSimpleContext = nullptr;
+  }
+
+  if (mDummyContext) {
+    // mContext and mDummyContext have the same slaveType and signal_data
+    // so no need for another workaround_gtk_im_display_closed.
+    gtk_im_context_set_client_window(mDummyContext, nullptr);
+    g_object_unref(mDummyContext);
+    mDummyContext = nullptr;
+  }
+
+  if (NS_WARN_IF(mComposingContext)) {
+    g_object_unref(mComposingContext);
+    mComposingContext = nullptr;
+  }
+
+  mOwnerWindow = nullptr;
+  mLastFocusedWindow = nullptr;
+  mInputContext.mIMEState.mEnabled = IMEEnabled::Disabled;
+  mPostingKeyEvents.Clear();
+
+  MOZ_LOG(gIMELog, LogLevel::Debug,
+          ("0x%p   OnDestroyWindow(), succeeded, Completely destroyed", this));
+}
+
+void IMContextWrapper::PrepareToDestroyContext(GtkIMContext* aContext) {
+  if (mIMContextID == IMContextID::IIIMF) {
+    // IIIM module registers handlers for the "closed" signal on the
+    // display, but the signal handler is not disconnected when the module
+    // is unloaded.  To prevent the module from being unloaded, use static
+    // variable to hold reference of slave context class declared by IIIM.
+    // Note that this does not grab any instance, it grabs the "class".
+    static gpointer sGtkIIIMContextClass = nullptr;
+    if (!sGtkIIIMContextClass) {
+      // We retrieved slave context class with g_type_name() and actual
+      // slave context instance when our widget was GTK2.  That must be
+      // _GtkIMContext::priv::slave in GTK3.  However, _GtkIMContext::priv
+      // is an opacity struct named _GtkIMMulticontextPrivate, i.e., it's
+      // not exposed by GTK3.  Therefore, we cannot access the instance
+      // safely.  So, we need to retrieve the slave context class with
+      // g_type_from_name("GtkIMContextIIIM") directly (anyway, we needed
+      // to compare the class name with "GtkIMContextIIIM").
+      GType IIMContextType = g_type_from_name("GtkIMContextIIIM");
+      if (IIMContextType) {
+        sGtkIIIMContextClass = g_type_class_ref(IIMContextType);
+        MOZ_LOG(gIMELog, LogLevel::Info,
+                ("0x%p PrepareToDestroyContext(), added to reference to "
+                 "GtkIMContextIIIM class to prevent it from being unloaded",
+                 this));
+      } else {
+        MOZ_LOG(gIMELog, LogLevel::Error,
+                ("0x%p PrepareToDestroyContext(), FAILED to prevent the "
+                 "IIIM module from being uploaded",
+                 this));
+      }
+    }
+  }
+}
+
+void IMContextWrapper::OnFocusWindow(nsWindow* aWindow) {
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return;
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnFocusWindow(aWindow=0x%p), mLastFocusedWindow=0x%p", this,
+           aWindow, mLastFocusedWindow));
+  mLastFocusedWindow = aWindow;
+}
+
+void IMContextWrapper::OnBlurWindow(nsWindow* aWindow) {
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return;
+  }
+
+  MOZ_LOG(
+      gIMELog, LogLevel::Info,
+      ("0x%p OnBlurWindow(aWindow=0x%p), mLastFocusedWindow=0x%p, "
+       "mIMEFocusState=%s",
+       this, aWindow, mLastFocusedWindow, ToString(mIMEFocusState).c_str()));
+
+  if (mLastFocusedWindow != aWindow) {
+    return;
+  }
+
+  NotifyIMEOfFocusChange(IMEFocusState::Blurred);
+}
+
+KeyHandlingState IMContextWrapper::OnKeyEvent(
+    nsWindow* aCaller, GdkEventKey* aEvent,
+    bool aKeyboardEventWasDispatched /* = false */) {
+  MOZ_ASSERT(aEvent, "aEvent must be non-null");
+
+  if (!mInputContext.mIMEState.IsEditable() || MOZ_UNLIKELY(IsDestroyed())) {
+    return KeyHandlingState::eNotHandled;
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Info, (">>>>>>>>>>>>>>>>"));
+  MOZ_LOG(
+      gIMELog, LogLevel::Info,
+      ("0x%p OnKeyEvent(aCaller=0x%p, "
+       "aEvent(0x%p): { type=%s, keyval=%s, unicode=0x%X, state=%s, "
+       "time=%u, hardware_keycode=%u, group=%u }, "
+       "aKeyboardEventWasDispatched=%s)",
+       this, aCaller, aEvent, GetEventType(aEvent),
+       gdk_keyval_name(aEvent->keyval), gdk_keyval_to_unicode(aEvent->keyval),
+       GetEventStateName(aEvent->state, mIMContextID).get(), aEvent->time,
+       aEvent->hardware_keycode, aEvent->group,
+       ToChar(aKeyboardEventWasDispatched)));
+  MOZ_LOG(
+      gIMELog, LogLevel::Info,
+      ("0x%p   OnKeyEvent(), mMaybeInDeadKeySequence=%s, "
+       "mCompositionState=%s, current context=%p, active context=%p, "
+       "mIMContextID=%s, mIsIMInAsyncKeyHandlingMode=%s",
+       this, ToChar(mMaybeInDeadKeySequence), GetCompositionStateName(),
+       GetCurrentContext(), GetActiveContext(), ToString(mIMContextID).c_str(),
+       ToChar(mIsIMInAsyncKeyHandlingMode)));
+
+  if (aCaller != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnKeyEvent(), FAILED, the caller isn't focused "
+             "window, mLastFocusedWindow=0x%p",
+             this, mLastFocusedWindow));
+    return KeyHandlingState::eNotHandled;
+  }
+
+  // Even if old IM context has composition, key event should be sent to
+  // current context since the user expects so.
+  GtkIMContext* currentContext = GetCurrentContext();
+  if (MOZ_UNLIKELY(!currentContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnKeyEvent(), FAILED, there are no context", this));
+    return KeyHandlingState::eNotHandled;
+  }
+
+  if (mSetCursorPositionOnKeyEvent) {
+    SetCursorPosition(currentContext);
+    mSetCursorPositionOnKeyEvent = false;
+  }
+
+  // Let's support dead key event even if active keyboard layout also
+  // supports complicated composition like CJK IME.
+  bool isDeadKey =
+      KeymapWrapper::ComputeDOMKeyNameIndex(aEvent) == KEY_NAME_INDEX_Dead;
+  mMaybeInDeadKeySequence |= isDeadKey;
+
+  // If current context is mSimpleContext, both ibus and fcitx handles key
+  // events synchronously.  So, only when current context is mContext which
+  // is GtkIMMulticontext, the key event may be handled by IME asynchronously.
+  bool probablyHandledAsynchronously =
+      mIsIMInAsyncKeyHandlingMode && currentContext == mContext;
+
+  // If we're not sure whether the event is handled asynchronously, this is
+  // set to true.
+  bool maybeHandledAsynchronously = false;
+
+  // If aEvent is a synthesized event for async handling, this will be set to
+  // true.
+  bool isHandlingAsyncEvent = false;
+
+  // If we've decided that the event won't be synthesized asyncrhonously
+  // by IME, but actually IME did it, this is set to true.
+  bool isUnexpectedAsyncEvent = false;
+
+  // If IM is ibus or fcitx and it handles key events asynchronously,
+  // they mark aEvent->state as "handled by me" when they post key event
+  // to another process.  Unfortunately, we need to check this hacky
+  // flag because it's difficult to store all pending key events by
+  // an array or a hashtable.
+  if (probablyHandledAsynchronously) {
+    switch (mIMContextID) {
+      case IMContextID::IBus: {
+        // See src/ibustypes.h
+        static const guint IBUS_IGNORED_MASK = 1 << 25;
+        // If IBUS_IGNORED_MASK was set to aEvent->state, the event
+        // has already been handled by another process and it wasn't
+        // used by IME.
+        isHandlingAsyncEvent = !!(aEvent->state & IBUS_IGNORED_MASK);
+        if (!isHandlingAsyncEvent) {
+          // On some environments, IBUS_IGNORED_MASK flag is not set as
+          // expected.  In such case, we keep pusing all events into the queue.
+          // I.e., that causes eating a lot of memory until it's blurred.
+          // Therefore, we need to check whether there is same timestamp event
+          // in the queue.  This redundant cost should be low because in most
+          // causes, key events in the queue should be 2 or 4.
+          isHandlingAsyncEvent =
+              mPostingKeyEvents.IndexOf(aEvent) != GdkEventKeyQueue::NoIndex();
+          if (isHandlingAsyncEvent) {
+            MOZ_LOG(gIMELog, LogLevel::Info,
+                    ("0x%p   OnKeyEvent(), aEvent->state does not have "
+                     "IBUS_IGNORED_MASK but "
+                     "same event in the queue.  So, assuming it's a "
+                     "synthesized event",
+                     this));
+          }
+        }
+
+        // If it's a synthesized event, let's remove it from the posting
+        // event queue first.  Otherwise the following blocks cannot use
+        // `break`.
+        if (isHandlingAsyncEvent) {
+          MOZ_LOG(gIMELog, LogLevel::Info,
+                  ("0x%p   OnKeyEvent(), aEvent->state has IBUS_IGNORED_MASK "
+                   "or aEvent is in the "
+                   "posting event queue, so, it won't be handled "
+                   "asynchronously anymore. Removing "
+                   "the posted events from the queue",
+                   this));
+          probablyHandledAsynchronously = false;
+          mPostingKeyEvents.RemoveEvent(aEvent);
+        }
+
+        // ibus won't send back key press events in a dead key sequcne.
+        if (mMaybeInDeadKeySequence && aEvent->type == GDK_KEY_PRESS) {
+          probablyHandledAsynchronously = false;
+          if (isHandlingAsyncEvent) {
+            isUnexpectedAsyncEvent = true;
+            break;
+          }
+          // Some keyboard layouts which have dead keys may send
+          // "empty" key event to make us call
+          // gtk_im_context_filter_keypress() to commit composed
+          // character during a GDK_KEY_PRESS event dispatching.
+          if (!gdk_keyval_to_unicode(aEvent->keyval) &&
+              !aEvent->hardware_keycode) {
+            isUnexpectedAsyncEvent = true;
+            break;
+          }
+          break;
+        }
+        // ibus may handle key events synchronously if focused editor is
+        // <input type="password"> or |ime-mode: disabled;|.  However, in
+        // some environments, not so actually.  Therefore, we need to check
+        // the result of gtk_im_context_filter_keypress() later.
+        if (mInputContext.mIMEState.mEnabled == IMEEnabled::Password) {
+          probablyHandledAsynchronously = false;
+          maybeHandledAsynchronously = !isHandlingAsyncEvent;
+          break;
+        }
+        break;
+      }
+      case IMContextID::Fcitx:
+      case IMContextID::Fcitx5: {
+        // See src/lib/fcitx-utils/keysym.h
+        static const guint FcitxKeyState_IgnoredMask = 1 << 25;
+        // If FcitxKeyState_IgnoredMask was set to aEvent->state,
+        // the event has already been handled by another process and
+        // it wasn't used by IME.
+        isHandlingAsyncEvent = !!(aEvent->state & FcitxKeyState_IgnoredMask);
+        if (!isHandlingAsyncEvent) {
+          // On some environments, FcitxKeyState_IgnoredMask flag *might* be not
+          // set as expected. If there were such cases, we'd keep pusing all
+          // events into the queue.  I.e., that would cause eating a lot of
+          // memory until it'd be blurred.  Therefore, we should check whether
+          // there is same timestamp event in the queue.  This redundant cost
+          // should be low because in most causes, key events in the queue
+          // should be 2 or 4.
+          isHandlingAsyncEvent =
+              mPostingKeyEvents.IndexOf(aEvent) != GdkEventKeyQueue::NoIndex();
+          if (isHandlingAsyncEvent) {
+            MOZ_LOG(gIMELog, LogLevel::Info,
+                    ("0x%p   OnKeyEvent(), aEvent->state does not have "
+                     "FcitxKeyState_IgnoredMask "
+                     "but same event in the queue.  So, assuming it's a "
+                     "synthesized event",
+                     this));
+          }
+        }
+
+        // fcitx won't send back key press events in a dead key sequcne.
+        if (mMaybeInDeadKeySequence && aEvent->type == GDK_KEY_PRESS) {
+          probablyHandledAsynchronously = false;
+          if (isHandlingAsyncEvent) {
+            isUnexpectedAsyncEvent = true;
+            break;
+          }
+          // Some keyboard layouts which have dead keys may send
+          // "empty" key event to make us call
+          // gtk_im_context_filter_keypress() to commit composed
+          // character during a GDK_KEY_PRESS event dispatching.
+          if (!gdk_keyval_to_unicode(aEvent->keyval) &&
+              !aEvent->hardware_keycode) {
+            isUnexpectedAsyncEvent = true;
+            break;
+          }
+        }
+
+        // fcitx handles key events asynchronously even if focused
+        // editor cannot use IME actually.
+
+        if (isHandlingAsyncEvent) {
+          MOZ_LOG(gIMELog, LogLevel::Info,
+                  ("0x%p   OnKeyEvent(), aEvent->state has "
+                   "FcitxKeyState_IgnoredMask or aEvent is in "
+                   "the posting event queue, so, it won't be handled "
+                   "asynchronously anymore. "
+                   "Removing the posted events from the queue",
+                   this));
+          probablyHandledAsynchronously = false;
+          mPostingKeyEvents.RemoveEvent(aEvent);
+          break;
+        }
+        break;
+      }
+      default:
+        MOZ_ASSERT_UNREACHABLE(
+            "IME may handle key event "
+            "asyncrhonously, but not yet confirmed if it comes agian "
+            "actually");
+    }
+  }
+
+  if (!isUnexpectedAsyncEvent) {
+    mKeyboardEventWasDispatched = aKeyboardEventWasDispatched;
+    mKeyboardEventWasConsumed = false;
+  } else {
+    // If we didn't expect this event, we've alreday dispatched eKeyDown
+    // event or eKeyUp event for that.
+    mKeyboardEventWasDispatched = true;
+    // And in this case, we need to assume that another key event hasn't
+    // been receivied and mKeyboardEventWasConsumed keeps storing the
+    // dispatched eKeyDown or eKeyUp event's state.
+  }
+  mFallbackToKeyEvent = false;
+  mProcessingKeyEvent = aEvent;
+  gboolean isFiltered = gtk_im_context_filter_keypress(currentContext, aEvent);
+
+  // If we're not sure whether the event is handled by IME asynchronously or
+  // synchronously, we need to trust the result of
+  // gtk_im_context_filter_keypress().  If it consumed and but did nothing,
+  // we can assume that another event will be synthesized.
+  if (!isHandlingAsyncEvent && maybeHandledAsynchronously) {
+    probablyHandledAsynchronously |=
+        isFiltered && !mFallbackToKeyEvent && !mKeyboardEventWasDispatched;
+  }
+
+  if (aEvent->type == GDK_KEY_PRESS) {
+    if (isFiltered && probablyHandledAsynchronously) {
+      sWaitingSynthesizedKeyPressHardwareKeyCode = aEvent->hardware_keycode;
+    } else {
+      sWaitingSynthesizedKeyPressHardwareKeyCode = 0;
+    }
+  }
+
+  // The caller of this shouldn't handle aEvent anymore if we've dispatched
+  // composition events or modified content with other events.
+  bool filterThisEvent = isFiltered && !mFallbackToKeyEvent;
+
+  if (IsComposingOnCurrentContext() && !isFiltered &&
+      aEvent->type == GDK_KEY_PRESS && mDispatchedCompositionString.IsEmpty()) {
+    // A Hangul input engine for SCIM doesn't emit preedit_end
+    // signal even when composition string becomes empty.  On the
+    // other hand, we should allow to make composition with empty
+    // string for other languages because there *might* be such
+    // IM.  For compromising this issue, we should dispatch
+    // compositionend event, however, we don't need to reset IM
+    // actually.
+    // NOTE: Don't dispatch key events as "processed by IME" since
+    // we need to dispatch keyboard events as IME wasn't handled it.
+    mProcessingKeyEvent = nullptr;
+    DispatchCompositionCommitEvent(currentContext, &EmptyString());
+    mProcessingKeyEvent = aEvent;
+    // In this case, even though we handle the keyboard event here,
+    // but we should dispatch keydown event as
+    filterThisEvent = false;
+  }
+
+  if (filterThisEvent && !mKeyboardEventWasDispatched) {
+    // If IME handled the key event but we've not dispatched eKeyDown nor
+    // eKeyUp event yet, we need to dispatch here unless the key event is
+    // now being handled by other IME process.
+    if (!probablyHandledAsynchronously) {
+      MaybeDispatchKeyEventAsProcessedByIME(eVoidEvent);
+      // Be aware, the widget might have been gone here.
+    }
+    // If we need to wait reply from IM, IM may send some signals to us
+    // without sending the key event again.  In such case, we need to
+    // dispatch keyboard events with a copy of aEvent.  Therefore, we
+    // need to use information of this key event to dispatch an KeyDown
+    // or eKeyUp event later.
+    else {
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   OnKeyEvent(), putting aEvent into the queue...", this));
+      mPostingKeyEvents.PutEvent(aEvent);
+    }
+  }
+
+  mProcessingKeyEvent = nullptr;
+
+  if (aEvent->type == GDK_KEY_PRESS && !filterThisEvent) {
+    // If the key event hasn't been handled by active IME nor keyboard
+    // layout, we can assume that the dead key sequence has been or was
+    // ended.  Note that we should not reset it when the key event is
+    // GDK_KEY_RELEASE since it may not be filtered by active keyboard
+    // layout even in composition.
+    mMaybeInDeadKeySequence = false;
+  }
+
+  MOZ_LOG(
+      gIMELog, LogLevel::Debug,
+      ("0x%p   OnKeyEvent(), succeeded, filterThisEvent=%s "
+       "(isFiltered=%s, mFallbackToKeyEvent=%s, "
+       "probablyHandledAsynchronously=%s, maybeHandledAsynchronously=%s), "
+       "mPostingKeyEvents.Length()=%zu, mCompositionState=%s, "
+       "mMaybeInDeadKeySequence=%s, mKeyboardEventWasDispatched=%s, "
+       "mKeyboardEventWasConsumed=%s",
+       this, ToChar(filterThisEvent), ToChar(isFiltered),
+       ToChar(mFallbackToKeyEvent), ToChar(probablyHandledAsynchronously),
+       ToChar(maybeHandledAsynchronously), mPostingKeyEvents.Length(),
+       GetCompositionStateName(), ToChar(mMaybeInDeadKeySequence),
+       ToChar(mKeyboardEventWasDispatched), ToChar(mKeyboardEventWasConsumed)));
+  MOZ_LOG(gIMELog, LogLevel::Info, ("<<<<<<<<<<<<<<<<\n\n"));
+
+  if (filterThisEvent) {
+    return KeyHandlingState::eHandled;
+  }
+  // If another call of this method has already dispatched eKeyDown event,
+  // we should return KeyHandlingState::eNotHandledButEventDispatched because
+  // the caller should've stopped handling the event if preceding eKeyDown
+  // event was consumed.
+  if (aKeyboardEventWasDispatched) {
+    return KeyHandlingState::eNotHandledButEventDispatched;
+  }
+  if (!mKeyboardEventWasDispatched) {
+    return KeyHandlingState::eNotHandled;
+  }
+  return mKeyboardEventWasConsumed
+             ? KeyHandlingState::eNotHandledButEventConsumed
+             : KeyHandlingState::eNotHandledButEventDispatched;
+}
+
+void IMContextWrapper::OnFocusChangeInGecko(bool aFocus) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnFocusChangeInGecko(aFocus=%s),mCompositionState=%s, "
+           "mIMEFocusState=%s, mSetInputPurposeAndInputHints=%s",
+           this, ToChar(aFocus), GetCompositionStateName(),
+           ToString(mIMEFocusState).c_str(),
+           ToChar(mSetInputPurposeAndInputHints)));
+
+  // We shouldn't carry over the removed string to another editor.
+  mSelectedStringRemovedByComposition.Truncate();
+  mContentSelection.reset();
+
+  if (aFocus) {
+    if (mSetInputPurposeAndInputHints) {
+      mSetInputPurposeAndInputHints = false;
+      SetInputPurposeAndInputHints();
+    }
+    NotifyIMEOfFocusChange(IMEFocusState::Focused);
+  } else {
+    NotifyIMEOfFocusChange(IMEFocusState::Blurred);
+  }
+
+  // When the focus changes, we need to inform IM about the new cursor
+  // position. Chinese input methods generally rely on this because they
+  // usually don't start composition until a character is picked.
+  if (aFocus && EnsureToCacheContentSelection()) {
+    SetCursorPosition(GetActiveContext());
+  }
+}
+
+void IMContextWrapper::ResetIME() {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p ResetIME(), mCompositionState=%s, mIMEFocusState=%s", this,
+           GetCompositionStateName(), ToString(mIMEFocusState).c_str()));
+
+  GtkIMContext* activeContext = GetActiveContext();
+  if (MOZ_UNLIKELY(!activeContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   ResetIME(), FAILED, there are no context", this));
+    return;
+  }
+
+  RefPtr<IMContextWrapper> kungFuDeathGrip(this);
+  RefPtr<nsWindow> lastFocusedWindow(mLastFocusedWindow);
+
+  mPendingResettingIMContext = false;
+  gtk_im_context_reset(activeContext);
+
+  // The last focused window might have been destroyed by a DOM event handler
+  // which was called by us during a call of gtk_im_context_reset().
+  if (!lastFocusedWindow ||
+      NS_WARN_IF(lastFocusedWindow != mLastFocusedWindow) ||
+      lastFocusedWindow->Destroyed()) {
+    return;
+  }
+
+  nsAutoString compositionString;
+  GetCompositionString(activeContext, compositionString);
+
+  MOZ_LOG(gIMELog, LogLevel::Debug,
+          ("0x%p   ResetIME() called gtk_im_context_reset(), "
+           "activeContext=0x%p, mCompositionState=%s, compositionString=%s, "
+           "mIMEFocusState=%s",
+           this, activeContext, GetCompositionStateName(),
+           NS_ConvertUTF16toUTF8(compositionString).get(),
+           ToString(mIMEFocusState).c_str()));
+
+  // XXX IIIMF (ATOK X3 which is one of the Language Engine of it is still
+  //     used in Japan!) sends only "preedit_changed" signal with empty
+  //     composition string synchronously.  Therefore, if composition string
+  //     is now empty string, we should assume that the IME won't send
+  //     "commit" signal.
+  if (IsComposing() && compositionString.IsEmpty()) {
+    // WARNING: The widget might have been gone after this.
+    DispatchCompositionCommitEvent(activeContext, &EmptyString());
+  }
+}
+
+nsresult IMContextWrapper::EndIMEComposition(nsWindow* aCaller) {
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return NS_OK;
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p EndIMEComposition(aCaller=0x%p), "
+           "mCompositionState=%s",
+           this, aCaller, GetCompositionStateName()));
+
+  if (aCaller != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   EndIMEComposition(), FAILED, the caller isn't "
+             "focused window, mLastFocusedWindow=0x%p",
+             this, mLastFocusedWindow));
+    return NS_OK;
+  }
+
+  if (!IsComposing()) {
+    return NS_OK;
+  }
+
+  // Currently, GTK has API neither to commit nor to cancel composition
+  // forcibly.  Therefore, TextComposition will recompute commit string for
+  // the request even if native IME will cause unexpected commit string.
+  // So, we don't need to emulate commit or cancel composition with
+  // proper composition events.
+  // XXX ResetIME() might not enough for finishing compositoin on some
+  //     environments.  We should emulate focus change too because some IMEs
+  //     may commit or cancel composition at blur.
+  ResetIME();
+
+  return NS_OK;
+}
+
+void IMContextWrapper::OnLayoutChange() {
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return;
+  }
+
+  if (IsComposing()) {
+    SetCursorPosition(GetActiveContext());
+  } else {
+    // If not composing, candidate window position is updated before key
+    // down
+    mSetCursorPositionOnKeyEvent = true;
+  }
+  mLayoutChanged = true;
+}
+
+void IMContextWrapper::OnUpdateComposition() {
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return;
+  }
+
+  if (!IsComposing()) {
+    // Composition has been committed.  So we need update selection for
+    // caret later
+    mContentSelection.reset();
+    EnsureToCacheContentSelection();
+    mSetCursorPositionOnKeyEvent = true;
+  }
+
+  // If we've already set candidate window position, we don't need to update
+  // the position with update composition notification.
+  if (!mLayoutChanged) {
+    SetCursorPosition(GetActiveContext());
+  }
+}
+
+void IMContextWrapper::SetInputContext(nsWindow* aCaller,
+                                       const InputContext* aContext,
+                                       const InputContextAction* aAction) {
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return;
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p SetInputContext(aCaller=0x%p, aContext={ mIMEState={ "
+           "mEnabled=%s }, mHTMLInputType=%s })",
+           this, aCaller, ToString(aContext->mIMEState.mEnabled).c_str(),
+           NS_ConvertUTF16toUTF8(aContext->mHTMLInputType).get()));
+
+  if (aCaller != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetInputContext(), FAILED, "
+             "the caller isn't focused window, mLastFocusedWindow=0x%p",
+             this, mLastFocusedWindow));
+    return;
+  }
+
+  if (!mContext) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetInputContext(), FAILED, "
+             "there are no context",
+             this));
+    return;
+  }
+
+  if (sLastFocusedContext != this) {
+    mInputContext = *aContext;
+    MOZ_LOG(gIMELog, LogLevel::Debug,
+            ("0x%p   SetInputContext(), succeeded, "
+             "but we're not active",
+             this));
+    return;
+  }
+
+  const bool changingEnabledState =
+      aContext->IsInputAttributeChanged(mInputContext);
+
+  // Release current IME focus if IME is enabled.
+  if (changingEnabledState && mInputContext.mIMEState.IsEditable()) {
+    if (IsComposing()) {
+      EndIMEComposition(mLastFocusedWindow);
+    }
+    if (mIMEFocusState == IMEFocusState::Focused) {
+      NotifyIMEOfFocusChange(IMEFocusState::BlurredWithoutFocusChange);
+    }
+  }
+
+  mInputContext = *aContext;
+  mSetInputPurposeAndInputHints = false;
+
+  if (!changingEnabledState || !mInputContext.mIMEState.IsEditable()) {
+    return;
+  }
+
+  // If the input context was temporarily disabled without a focus change,
+  // it must be ready to query content even if the focused content is in
+  // a remote process.  In this case, we should set IME focus right now.
+  if (mIMEFocusState == IMEFocusState::BlurredWithoutFocusChange) {
+    SetInputPurposeAndInputHints();
+    NotifyIMEOfFocusChange(IMEFocusState::Focused);
+    return;
+  }
+
+  // Otherwise, we cannot set input-purpose and input-hints right now because
+  // setting them may require to set focus immediately for IME own's UI.
+  // However, at this moment, `ContentCacheInParent` does not have content
+  // cache, it'll be available after `NOTIFY_IME_OF_FOCUS` notification.
+  // Therefore, we set them at receiving the notification.
+  mSetInputPurposeAndInputHints = true;
+}
+
+void IMContextWrapper::SetInputPurposeAndInputHints() {
+  GtkIMContext* currentContext = GetCurrentContext();
+  if (!currentContext) {
+    return;
+  }
+
+  GtkInputPurpose purpose = GTK_INPUT_PURPOSE_FREE_FORM;
+  const nsString& inputType = mInputContext.mHTMLInputType;
+  // Password case has difficult issue.  Desktop IMEs disable composition if
+  // input-purpose is password.  For disabling IME on |ime-mode: disabled;|, we
+  // need to check mEnabled value instead of inputType value.  This hack also
+  // enables composition on <input type="password" style="ime-mode: enabled;">.
+  // This is right behavior of ime-mode on desktop.
+  //
+  // On the other hand, IME for tablet devices may provide a specific software
+  // keyboard for password field.  If so, the behavior might look strange on
+  // both:
+  //   <input type="text" style="ime-mode: disabled;">
+  //   <input type="password" style="ime-mode: enabled;">
+  //
+  // Temporarily, we should focus on desktop environment for now.  I.e., let's
+  // ignore tablet devices for now.  When somebody reports actual trouble on
+  // tablet devices, we should try to look for a way to solve actual problem.
+  if (mInputContext.mIMEState.mEnabled == IMEEnabled::Password) {
+    purpose = GTK_INPUT_PURPOSE_PASSWORD;
+  } else if (inputType.EqualsLiteral("email")) {
+    purpose = GTK_INPUT_PURPOSE_EMAIL;
+  } else if (inputType.EqualsLiteral("url")) {
+    purpose = GTK_INPUT_PURPOSE_URL;
+  } else if (inputType.EqualsLiteral("tel")) {
+    purpose = GTK_INPUT_PURPOSE_PHONE;
+  } else if (inputType.EqualsLiteral("number")) {
+    purpose = GTK_INPUT_PURPOSE_NUMBER;
+  } else if (mInputContext.mHTMLInputMode.EqualsLiteral("decimal")) {
+    purpose = GTK_INPUT_PURPOSE_NUMBER;
+  } else if (mInputContext.mHTMLInputMode.EqualsLiteral("email")) {
+    purpose = GTK_INPUT_PURPOSE_EMAIL;
+  } else if (mInputContext.mHTMLInputMode.EqualsLiteral("numeric")) {
+    purpose = GTK_INPUT_PURPOSE_DIGITS;
+  } else if (mInputContext.mHTMLInputMode.EqualsLiteral("tel")) {
+    purpose = GTK_INPUT_PURPOSE_PHONE;
+  } else if (mInputContext.mHTMLInputMode.EqualsLiteral("url")) {
+    purpose = GTK_INPUT_PURPOSE_URL;
+  }
+  // Search by type and inputmode isn't supported on GTK.
+
+  g_object_set(currentContext, "input-purpose", purpose, nullptr);
+
+  // Although GtkInputHints is enum type, value is bit field.
+  gint hints = GTK_INPUT_HINT_NONE;
+  if (mInputContext.mHTMLInputMode.EqualsLiteral("none")) {
+    hints |= GTK_INPUT_HINT_INHIBIT_OSK;
+  }
+
+  if (mInputContext.mAutocapitalize.EqualsLiteral("characters")) {
+    hints |= GTK_INPUT_HINT_UPPERCASE_CHARS;
+  } else if (mInputContext.mAutocapitalize.EqualsLiteral("sentences")) {
+    hints |= GTK_INPUT_HINT_UPPERCASE_SENTENCES;
+  } else if (mInputContext.mAutocapitalize.EqualsLiteral("words")) {
+    hints |= GTK_INPUT_HINT_UPPERCASE_WORDS;
+  }
+
+  g_object_set(currentContext, "input-hints", hints, nullptr);
+}
+
+InputContext IMContextWrapper::GetInputContext() {
+  mInputContext.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED;
+  return mInputContext;
+}
+
+GtkIMContext* IMContextWrapper::GetCurrentContext() const {
+  if (IsEnabled()) {
+    return mContext;
+  }
+  if (mInputContext.mIMEState.mEnabled == IMEEnabled::Password) {
+    return mSimpleContext;
+  }
+  return mDummyContext;
+}
+
+bool IMContextWrapper::IsValidContext(GtkIMContext* aContext) const {
+  if (!aContext) {
+    return false;
+  }
+  return aContext == mContext || aContext == mSimpleContext ||
+         aContext == mDummyContext;
+}
+
+bool IMContextWrapper::IsEnabled() const {
+  return mInputContext.mIMEState.mEnabled == IMEEnabled::Enabled ||
+         (!sUseSimpleContext &&
+          mInputContext.mIMEState.mEnabled == IMEEnabled::Password);
+}
+
+void IMContextWrapper::NotifyIMEOfFocusChange(IMEFocusState aIMEFocusState) {
+  MOZ_ASSERT_IF(aIMEFocusState == IMEFocusState::BlurredWithoutFocusChange,
+                mIMEFocusState != IMEFocusState::Blurred);
+  if (mIMEFocusState == aIMEFocusState) {
+    return;
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p NotifyIMEOfFocusChange(aIMEFocusState=%s), mIMEFocusState=%s, "
+           "sLastFocusedContext=0x%p",
+           this, ToString(aIMEFocusState).c_str(),
+           ToString(mIMEFocusState).c_str(), sLastFocusedContext));
+  MOZ_ASSERT(!mSetInputPurposeAndInputHints);
+
+  // If we've already made IME blurred at setting the input context disabled
+  // and it's now completely blurred by a focus move, we need only to update
+  // mIMEFocusState and when the input context gets enabled, we cannot set
+  // IME focus immediately.
+  if (aIMEFocusState == IMEFocusState::Blurred &&
+      mIMEFocusState == IMEFocusState::BlurredWithoutFocusChange) {
+    mIMEFocusState = IMEFocusState::Blurred;
+    return;
+  }
+
+  auto Blur = [&](IMEFocusState aInternalState) {
+    GtkIMContext* currentContext = GetCurrentContext();
+    if (MOZ_UNLIKELY(!currentContext)) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   NotifyIMEOfFocusChange()::Blur(), FAILED, "
+               "there is no context",
+               this));
+      return;
+    }
+    gtk_im_context_focus_out(currentContext);
+    mIMEFocusState = aInternalState;
+  };
+
+  if (aIMEFocusState != IMEFocusState::Focused) {
+    return Blur(aIMEFocusState);
+  }
+
+  GtkIMContext* currentContext = GetCurrentContext();
+  if (MOZ_UNLIKELY(!currentContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   NotifyIMEOfFocusChange(), FAILED, "
+             "there is no context",
+             this));
+    return;
+  }
+
+  if (sLastFocusedContext && sLastFocusedContext != this) {
+    sLastFocusedContext->NotifyIMEOfFocusChange(IMEFocusState::Blurred);
+  }
+
+  sLastFocusedContext = this;
+
+  // Forget all posted key events when focus is moved since they shouldn't
+  // be fired in different editor.
+  sWaitingSynthesizedKeyPressHardwareKeyCode = 0;
+  mPostingKeyEvents.Clear();
+
+  gtk_im_context_focus_in(currentContext);
+  mIMEFocusState = aIMEFocusState;
+  mSetCursorPositionOnKeyEvent = true;
+
+  if (!IsEnabled()) {
+    // We should release IME focus for uim and scim.
+    // These IMs are using snooper that is released at losing focus.
+    Blur(IMEFocusState::BlurredWithoutFocusChange);
+  }
+}
+
+void IMContextWrapper::OnSelectionChange(
+    nsWindow* aCaller, const IMENotification& aIMENotification) {
+  const bool isSelectionRangeChanged =
+      mContentSelection.isNothing() ||
+      !aIMENotification.mSelectionChangeData.EqualsRange(
+          mContentSelection.ref());
+  mContentSelection =
+      Some(ContentSelection(aIMENotification.mSelectionChangeData));
+  const bool retrievedSurroundingSignalReceived =
+      mRetrieveSurroundingSignalReceived;
+  mRetrieveSurroundingSignalReceived = false;
+
+  if (MOZ_UNLIKELY(IsDestroyed())) {
+    return;
+  }
+
+  const IMENotification::SelectionChangeDataBase& selectionChangeData =
+      aIMENotification.mSelectionChangeData;
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnSelectionChange(aCaller=0x%p, aIMENotification={ "
+           "mSelectionChangeData=%s }), "
+           "mCompositionState=%s, mIsDeletingSurrounding=%s, "
+           "mRetrieveSurroundingSignalReceived=%s, isSelectionRangeChanged=%s",
+           this, aCaller, ToString(selectionChangeData).c_str(),
+           GetCompositionStateName(), ToChar(mIsDeletingSurrounding),
+           ToChar(retrievedSurroundingSignalReceived),
+           ToChar(isSelectionRangeChanged)));
+
+  if (aCaller != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnSelectionChange(), FAILED, "
+             "the caller isn't focused window, mLastFocusedWindow=0x%p",
+             this, mLastFocusedWindow));
+    return;
+  }
+
+  if (!IsComposing()) {
+    // Now we have no composition (mostly situation on calling this method)
+    // If we have it, it will set by
+    // NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED.
+    mSetCursorPositionOnKeyEvent = true;
+  }
+
+  // The focused editor might have placeholder text with normal text node.
+  // In such case, the text node must be removed from a compositionstart
+  // event handler.  So, we're dispatching eCompositionStart,
+  // we should ignore selection change notification.
+  if (mCompositionState == eCompositionState_CompositionStartDispatched) {
+    if (NS_WARN_IF(mContentSelection.isNothing())) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   OnSelectionChange(), FAILED, "
+               "new offset is too large, cannot keep composing",
+               this));
+    } else if (mContentSelection->HasRange()) {
+      // Modify the selection start offset with new offset.
+      mCompositionStart = mContentSelection->OffsetAndDataRef().StartOffset();
+      // XXX We should modify mSelectedStringRemovedByComposition?
+      // But how?
+      MOZ_LOG(gIMELog, LogLevel::Debug,
+              ("0x%p   OnSelectionChange(), ignored, mCompositionStart "
+               "is updated to %u, the selection change doesn't cause "
+               "resetting IM context",
+               this, mCompositionStart));
+      // And don't reset the IM context.
+      return;
+    } else {
+      MOZ_LOG(
+          gIMELog, LogLevel::Debug,
+          ("0x%p   OnSelectionChange(), ignored, because of no selection range",
+           this));
+      return;
+    }
+    // Otherwise, reset the IM context due to impossible to keep composing.
+  }
+
+  // If the selection change is caused by deleting surrounding text,
+  // we shouldn't need to notify IME of selection change.
+  if (mIsDeletingSurrounding) {
+    return;
+  }
+
+  bool occurredBeforeComposition =
+      IsComposing() && !selectionChangeData.mOccurredDuringComposition &&
+      !selectionChangeData.mCausedByComposition;
+  if (occurredBeforeComposition) {
+    mPendingResettingIMContext = true;
+  }
+
+  // When the selection change is caused by dispatching composition event,
+  // selection set event and/or occurred before starting current composition,
+  // we shouldn't notify IME of that and commit existing composition.
+  // Don't do this even if selection is not changed actually.  For example,
+  // fcitx has direct input mode which does not insert composing string, but
+  // inserts commited text for each key sequence (i.e., there is "invisible"
+  // composition string).  In the world after bug 1712269, we don't use a
+  // set of composition events for this kind of IME.  Therefore,
+  // SelectionChangeData.mCausedByComposition is not expected value for here
+  // if this call is caused by a preceding commit.  And if the preceding commit
+  // is triggered by a key type for next word, resetting IME state makes fcitx
+  // discard the pending input for the next word.  Thus, we need to check
+  // whether the selection range is actually changed here.
+  if (!selectionChangeData.mCausedByComposition &&
+      !selectionChangeData.mCausedBySelectionEvent && isSelectionRangeChanged &&
+      !occurredBeforeComposition) {
+    // Hack for ibus-pinyin.  ibus-pinyin will synthesize a set of
+    // composition which commits with empty string after calling
+    // gtk_im_context_reset().  Therefore, selecting text causes
+    // unexpectedly removing it.  For preventing it but not breaking the
+    // other IMEs which use surrounding text, we should call it only when
+    // surrounding text has been retrieved after last selection range was
+    // set.  If it's not retrieved, that means that current IME doesn't
+    // have any content cache, so, it must not need the notification of
+    // selection change.
+    if (IsComposing() || retrievedSurroundingSignalReceived) {
+      ResetIME();
+    }
+  }
+}
+
+/* static */
+void IMContextWrapper::OnThemeChanged() {
+  if (auto* provider = SelectionStyleProvider::GetExistingInstance()) {
+    provider->OnThemeChanged();
+  }
+}
+
+/* static */
+void IMContextWrapper::OnStartCompositionCallback(GtkIMContext* aContext,
+                                                  IMContextWrapper* aModule) {
+  aModule->OnStartCompositionNative(aContext);
+}
+
+void IMContextWrapper::OnStartCompositionNative(GtkIMContext* aContext) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnStartCompositionNative(aContext=0x%p), "
+           "current context=0x%p, mComposingContext=0x%p",
+           this, aContext, GetCurrentContext(), mComposingContext));
+
+  // See bug 472635, we should do nothing if IM context doesn't match.
+  if (GetCurrentContext() != aContext) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnStartCompositionNative(), FAILED, "
+             "given context doesn't match",
+             this));
+    return;
+  }
+
+  if (mComposingContext && aContext != mComposingContext) {
+    // XXX For now, we should ignore this odd case, just logging.
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   OnStartCompositionNative(), Warning, "
+             "there is already a composing context but starting new "
+             "composition with different context",
+             this));
+  }
+
+  // IME may start composition without "preedit_start" signal.  Therefore,
+  // mComposingContext will be initialized in DispatchCompositionStart().
+
+  if (!DispatchCompositionStart(aContext)) {
+    return;
+  }
+  mCompositionTargetRange.mOffset = mCompositionStart;
+  mCompositionTargetRange.mLength = 0;
+}
+
+/* static */
+void IMContextWrapper::OnEndCompositionCallback(GtkIMContext* aContext,
+                                                IMContextWrapper* aModule) {
+  aModule->OnEndCompositionNative(aContext);
+}
+
+void IMContextWrapper::OnEndCompositionNative(GtkIMContext* aContext) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnEndCompositionNative(aContext=0x%p), mComposingContext=0x%p",
+           this, aContext, mComposingContext));
+
+  // See bug 472635, we should do nothing if IM context doesn't match.
+  // Note that if this is called after focus move, the context may different
+  // from any our owning context.
+  if (!IsValidContext(aContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p    OnEndCompositionNative(), FAILED, "
+             "given context doesn't match with any context",
+             this));
+    return;
+  }
+
+  // If we've not started composition with aContext, we should ignore it.
+  if (aContext != mComposingContext) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p    OnEndCompositionNative(), Warning, "
+             "given context doesn't match with mComposingContext",
+             this));
+    return;
+  }
+
+  g_object_unref(mComposingContext);
+  mComposingContext = nullptr;
+
+  // If we already handled the commit event, we should do nothing here.
+  if (IsComposing()) {
+    if (!DispatchCompositionCommitEvent(aContext)) {
+      // If the widget is destroyed, we should do nothing anymore.
+      return;
+    }
+  }
+
+  if (mPendingResettingIMContext) {
+    ResetIME();
+  }
+}
+
+/* static */
+void IMContextWrapper::OnChangeCompositionCallback(GtkIMContext* aContext,
+                                                   IMContextWrapper* aModule) {
+  aModule->OnChangeCompositionNative(aContext);
+}
+
+void IMContextWrapper::OnChangeCompositionNative(GtkIMContext* aContext) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnChangeCompositionNative(aContext=0x%p), "
+           "mComposingContext=0x%p",
+           this, aContext, mComposingContext));
+
+  // See bug 472635, we should do nothing if IM context doesn't match.
+  // Note that if this is called after focus move, the context may different
+  // from any our owning context.
+  if (!IsValidContext(aContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnChangeCompositionNative(), FAILED, "
+             "given context doesn't match with any context",
+             this));
+    return;
+  }
+
+  if (mComposingContext && aContext != mComposingContext) {
+    // XXX For now, we should ignore this odd case, just logging.
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   OnChangeCompositionNative(), Warning, "
+             "given context doesn't match with composing context",
+             this));
+  }
+
+  nsAutoString compositionString;
+  GetCompositionString(aContext, compositionString);
+  if (!IsComposing() && compositionString.IsEmpty()) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   OnChangeCompositionNative(), Warning, does nothing "
+             "because has not started composition and composing string is "
+             "empty",
+             this));
+    mDispatchedCompositionString.Truncate();
+    return;  // Don't start the composition with empty string.
+  }
+
+  // Be aware, widget can be gone
+  DispatchCompositionChangeEvent(aContext, compositionString);
+}
+
+/* static */
+gboolean IMContextWrapper::OnRetrieveSurroundingCallback(
+    GtkIMContext* aContext, IMContextWrapper* aModule) {
+  return aModule->OnRetrieveSurroundingNative(aContext);
+}
+
+gboolean IMContextWrapper::OnRetrieveSurroundingNative(GtkIMContext* aContext) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnRetrieveSurroundingNative(aContext=0x%p), "
+           "current context=0x%p",
+           this, aContext, GetCurrentContext()));
+
+  // See bug 472635, we should do nothing if IM context doesn't match.
+  if (GetCurrentContext() != aContext) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnRetrieveSurroundingNative(), FAILED, "
+             "given context doesn't match",
+             this));
+    return FALSE;
+  }
+
+  nsAutoString uniStr;
+  uint32_t cursorPos;
+  if (NS_FAILED(GetCurrentParagraph(uniStr, cursorPos))) {
+    return FALSE;
+  }
+
+  // Despite taking a pointer and a length, IBus wants the string to be
+  // zero-terminated and doesn't like U+0000 within the string.
+  uniStr.ReplaceChar(char16_t(0), char16_t(0xFFFD));
+
+  NS_ConvertUTF16toUTF8 utf8Str(nsDependentSubstring(uniStr, 0, cursorPos));
+  uint32_t cursorPosInUTF8 = utf8Str.Length();
+  AppendUTF16toUTF8(nsDependentSubstring(uniStr, cursorPos), utf8Str);
+  gtk_im_context_set_surrounding(aContext, utf8Str.get(), utf8Str.Length(),
+                                 cursorPosInUTF8);
+  mRetrieveSurroundingSignalReceived = true;
+  return TRUE;
+}
+
+/* static */
+gboolean IMContextWrapper::OnDeleteSurroundingCallback(
+    GtkIMContext* aContext, gint aOffset, gint aNChars,
+    IMContextWrapper* aModule) {
+  return aModule->OnDeleteSurroundingNative(aContext, aOffset, aNChars);
+}
+
+gboolean IMContextWrapper::OnDeleteSurroundingNative(GtkIMContext* aContext,
+                                                     gint aOffset,
+                                                     gint aNChars) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnDeleteSurroundingNative(aContext=0x%p, aOffset=%d, "
+           "aNChar=%d), current context=0x%p",
+           this, aContext, aOffset, aNChars, GetCurrentContext()));
+
+  // See bug 472635, we should do nothing if IM context doesn't match.
+  if (GetCurrentContext() != aContext) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnDeleteSurroundingNative(), FAILED, "
+             "given context doesn't match",
+             this));
+    return FALSE;
+  }
+
+  AutoRestore<bool> saveDeletingSurrounding(mIsDeletingSurrounding);
+  mIsDeletingSurrounding = true;
+  if (NS_SUCCEEDED(DeleteText(aContext, aOffset, (uint32_t)aNChars))) {
+    return TRUE;
+  }
+
+  // failed
+  MOZ_LOG(gIMELog, LogLevel::Error,
+          ("0x%p   OnDeleteSurroundingNative(), FAILED, "
+           "cannot delete text",
+           this));
+  return FALSE;
+}
+
+/* static */
+void IMContextWrapper::OnCommitCompositionCallback(GtkIMContext* aContext,
+                                                   const gchar* aString,
+                                                   IMContextWrapper* aModule) {
+  aModule->OnCommitCompositionNative(aContext, aString);
+}
+
+void IMContextWrapper::OnCommitCompositionNative(GtkIMContext* aContext,
+                                                 const gchar* aUTF8Char) {
+  const gchar emptyStr = 0;
+  const gchar* commitString = aUTF8Char ? aUTF8Char : &emptyStr;
+  NS_ConvertUTF8toUTF16 utf16CommitString(commitString);
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p OnCommitCompositionNative(aContext=0x%p), "
+           "current context=0x%p, active context=0x%p, commitString=\"%s\", "
+           "mProcessingKeyEvent=0x%p, IsComposingOn(aContext)=%s",
+           this, aContext, GetCurrentContext(), GetActiveContext(),
+           commitString, mProcessingKeyEvent, ToChar(IsComposingOn(aContext))));
+
+  // See bug 472635, we should do nothing if IM context doesn't match.
+  if (!IsValidContext(aContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   OnCommitCompositionNative(), FAILED, "
+             "given context doesn't match",
+             this));
+    return;
+  }
+
+  // If we are not in composition and committing with empty string,
+  // we need to do nothing because if we continued to handle this
+  // signal, we would dispatch compositionstart, text, compositionend
+  // events with empty string.  Of course, they are unnecessary events
+  // for Web applications and our editor.
+  if (!IsComposingOn(aContext) && utf16CommitString.IsEmpty()) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   OnCommitCompositionNative(), Warning, does nothing "
+             "because has not started composition and commit string is empty",
+             this));
+    return;
+  }
+
+  // If IME doesn't change their keyevent that generated this commit,
+  // we should treat that IME didn't handle the key event because
+  // web applications want to receive "keydown" and "keypress" event
+  // in such case.
+  // NOTE: While a key event is being handled, this might be caused on
+  // current context.  Otherwise, this may be caused on active context.
+  if (!IsComposingOn(aContext) && mProcessingKeyEvent &&
+      mProcessingKeyEvent->type == GDK_KEY_PRESS &&
+      aContext == GetCurrentContext()) {
+    char keyval_utf8[8]; /* should have at least 6 bytes of space */
+    gint keyval_utf8_len;
+    guint32 keyval_unicode;
+
+    keyval_unicode = gdk_keyval_to_unicode(mProcessingKeyEvent->keyval);
+    keyval_utf8_len = g_unichar_to_utf8(keyval_unicode, keyval_utf8);
+    keyval_utf8[keyval_utf8_len] = '\0';
+
+    // If committing string is exactly same as a character which is
+    // produced by the key, eKeyDown and eKeyPress event should be
+    // dispatched by the caller of OnKeyEvent() normally.  Note that
+    // mMaybeInDeadKeySequence will be set to false by OnKeyEvent()
+    // since we set mFallbackToKeyEvent to true here.
+    if (!strcmp(commitString, keyval_utf8)) {
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   OnCommitCompositionNative(), "
+               "we'll send normal key event",
+               this));
+      mFallbackToKeyEvent = true;
+      return;
+    }
+
+    // If we're in a dead key sequence, commit string is a character in
+    // the BMP and mProcessingKeyEvent produces some characters but it's
+    // not same as committing string, we should dispatch an eKeyPress
+    // event from here.
+    WidgetKeyboardEvent keyDownEvent(true, eKeyDown, mLastFocusedWindow);
+    KeymapWrapper::InitKeyEvent(keyDownEvent, mProcessingKeyEvent, false);
+    if (mMaybeInDeadKeySequence && utf16CommitString.Length() == 1 &&
+        keyDownEvent.mKeyNameIndex == KEY_NAME_INDEX_USE_STRING) {
+      mKeyboardEventWasDispatched = true;
+      // Anyway, we're not in dead key sequence anymore.
+      mMaybeInDeadKeySequence = false;
+
+      RefPtr<TextEventDispatcher> dispatcher = GetTextEventDispatcher();
+      nsresult rv = dispatcher->BeginNativeInputTransaction();
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        MOZ_LOG(gIMELog, LogLevel::Error,
+                ("0x%p   OnCommitCompositionNative(), FAILED, "
+                 "due to BeginNativeInputTransaction() failure",
+                 this));
+        return;
+      }
+
+      // First, dispatch eKeyDown event.
+      keyDownEvent.mKeyValue = utf16CommitString;
+      nsEventStatus status = nsEventStatus_eIgnore;
+      bool dispatched = dispatcher->DispatchKeyboardEvent(
+          eKeyDown, keyDownEvent, status, mProcessingKeyEvent);
+      if (!dispatched || status == nsEventStatus_eConsumeNoDefault) {
+        mKeyboardEventWasConsumed = true;
+        MOZ_LOG(gIMELog, LogLevel::Info,
+                ("0x%p   OnCommitCompositionNative(), "
+                 "doesn't dispatch eKeyPress event because the preceding "
+                 "eKeyDown event was not dispatched or was consumed",
+                 this));
+        return;
+      }
+      if (mLastFocusedWindow != keyDownEvent.mWidget ||
+          mLastFocusedWindow->Destroyed()) {
+        MOZ_LOG(gIMELog, LogLevel::Warning,
+                ("0x%p   OnCommitCompositionNative(), Warning, "
+                 "stop dispatching eKeyPress event because the preceding "
+                 "eKeyDown event caused changing focused widget or "
+                 "destroyed",
+                 this));
+        return;
+      }
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   OnCommitCompositionNative(), "
+               "dispatched eKeyDown event for the committed character",
+               this));
+
+      // Next, dispatch eKeyPress event.
+      dispatcher->MaybeDispatchKeypressEvents(keyDownEvent, status,
+                                              mProcessingKeyEvent);
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   OnCommitCompositionNative(), "
+               "dispatched eKeyPress event for the committed character",
+               this));
+      return;
+    }
+  }
+
+  NS_ConvertUTF8toUTF16 str(commitString);
+  // Be aware, widget can be gone
+  DispatchCompositionCommitEvent(aContext, &str);
+}
+
+void IMContextWrapper::GetCompositionString(GtkIMContext* aContext,
+                                            nsAString& aCompositionString) {
+  gchar* preedit_string;
+  gint cursor_pos;
+  PangoAttrList* feedback_list;
+  gtk_im_context_get_preedit_string(aContext, &preedit_string, &feedback_list,
+                                    &cursor_pos);
+  if (preedit_string && *preedit_string) {
+    CopyUTF8toUTF16(MakeStringSpan(preedit_string), aCompositionString);
+  } else {
+    aCompositionString.Truncate();
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p GetCompositionString(aContext=0x%p), "
+           "aCompositionString=\"%s\"",
+           this, aContext, preedit_string));
+
+  pango_attr_list_unref(feedback_list);
+  g_free(preedit_string);
+}
+
+bool IMContextWrapper::MaybeDispatchKeyEventAsProcessedByIME(
+    EventMessage aFollowingEvent) {
+  if (!mLastFocusedWindow) {
+    return false;
+  }
+
+  if (!mIsKeySnooped &&
+      ((!mProcessingKeyEvent && mPostingKeyEvents.IsEmpty()) ||
+       (mProcessingKeyEvent && mKeyboardEventWasDispatched))) {
+    return true;
+  }
+
+  // A "keydown" or "keyup" event handler may change focus with the
+  // following event.  In such case, we need to cancel this composition.
+  // So, we need to store IM context now because mComposingContext may be
+  // overwritten with different context if calling this method recursively.
+  // Note that we don't need to grab the context here because |context|
+  // will be used only for checking if it's same as mComposingContext.
+  GtkIMContext* oldCurrentContext = GetCurrentContext();
+  GtkIMContext* oldComposingContext = mComposingContext;
+
+  RefPtr<nsWindow> lastFocusedWindow(mLastFocusedWindow);
+
+  if (mProcessingKeyEvent || !mPostingKeyEvents.IsEmpty()) {
+    if (mProcessingKeyEvent) {
+      mKeyboardEventWasDispatched = true;
+    }
+    // If we're not handling a key event synchronously, the signal may be
+    // sent by IME without sending key event to us.  In such case, we
+    // should dispatch keyboard event for the last key event which was
+    // posted to other IME process.
+    GdkEventKey* sourceEvent = mProcessingKeyEvent
+                                   ? mProcessingKeyEvent
+                                   : mPostingKeyEvents.GetFirstEvent();
+
+    MOZ_LOG(
+        gIMELog, LogLevel::Info,
+        ("0x%p MaybeDispatchKeyEventAsProcessedByIME("
+         "aFollowingEvent=%s), dispatch %s %s "
+         "event: { type=%s, keyval=%s, unicode=0x%X, state=%s, "
+         "time=%u, hardware_keycode=%u, group=%u }",
+         this, ToChar(aFollowingEvent),
+         ToChar(sourceEvent->type == GDK_KEY_PRESS ? eKeyDown : eKeyUp),
+         mProcessingKeyEvent ? "processing" : "posted",
+         GetEventType(sourceEvent), gdk_keyval_name(sourceEvent->keyval),
+         gdk_keyval_to_unicode(sourceEvent->keyval),
+         GetEventStateName(sourceEvent->state, mIMContextID).get(),
+         sourceEvent->time, sourceEvent->hardware_keycode, sourceEvent->group));
+
+    // Let's dispatch eKeyDown event or eKeyUp event now.  Note that only
+    // when we're not in a dead key composition, we should mark the
+    // eKeyDown and eKeyUp event as "processed by IME" since we should
+    // expose raw keyCode and key value to web apps the key event is a
+    // part of a dead key sequence.
+    // FYI: We should ignore if default of preceding keydown or keyup
+    //      event is prevented since even on the other browsers, web
+    //      applications cannot cancel the following composition event.
+    //      Spec bug: https://github.com/w3c/uievents/issues/180
+    KeymapWrapper::DispatchKeyDownOrKeyUpEvent(lastFocusedWindow, sourceEvent,
+                                               !mMaybeInDeadKeySequence,
+                                               &mKeyboardEventWasConsumed);
+    MOZ_LOG(gIMELog, LogLevel::Info,
+            ("0x%p   MaybeDispatchKeyEventAsProcessedByIME(), keydown or keyup "
+             "event is dispatched",
+             this));
+
+    if (!mProcessingKeyEvent) {
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   MaybeDispatchKeyEventAsProcessedByIME(), removing first "
+               "event from the queue",
+               this));
+      mPostingKeyEvents.RemoveEvent(sourceEvent);
+    }
+  } else {
+    MOZ_ASSERT(mIsKeySnooped);
+    // Currently, we support key snooper mode of uim and wayland only.
+    MOZ_ASSERT(mIMContextID == IMContextID::Uim ||
+               mIMContextID == IMContextID::Wayland);
+    // uim sends "preedit_start" signal and "preedit_changed" separately
+    // at starting composition, "commit" and "preedit_end" separately at
+    // committing composition.
+
+    // Currently, we should dispatch only fake eKeyDown event because
+    // we cannot decide which is the last signal of each key operation
+    // and Chromium also dispatches only "keydown" event in this case.
+    bool dispatchFakeKeyDown = false;
+    switch (aFollowingEvent) {
+      case eCompositionStart:
+      case eCompositionCommit:
+      case eCompositionCommitAsIs:
+      case eContentCommandInsertText:
+        dispatchFakeKeyDown = true;
+        break;
+      // XXX Unfortunately, I don't have a good idea to prevent to
+      //     dispatch redundant eKeyDown event for eCompositionStart
+      //     immediately after "delete_surrounding" signal.  However,
+      //     not dispatching eKeyDown event is worse than dispatching
+      //     redundant eKeyDown events.
+      case eContentCommandDelete:
+        dispatchFakeKeyDown = true;
+        break;
+      // We need to prevent to dispatch redundant eKeyDown event for
+      // eCompositionChange immediately after eCompositionStart.  So,
+      // We should not dispatch eKeyDown event if dispatched composition
+      // string is still empty string.
+      case eCompositionChange:
+        dispatchFakeKeyDown = !mDispatchedCompositionString.IsEmpty();
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE("Do you forget to handle the case?");
+        break;
+    }
+
+    if (dispatchFakeKeyDown) {
+      WidgetKeyboardEvent fakeKeyDownEvent(true, eKeyDown, lastFocusedWindow);
+      fakeKeyDownEvent.mKeyCode = NS_VK_PROCESSKEY;
+      fakeKeyDownEvent.mKeyNameIndex = KEY_NAME_INDEX_Process;
+      // It's impossible to get physical key information in this case but
+      // this should be okay since web apps shouldn't do anything with
+      // physical key information during composition.
+      fakeKeyDownEvent.mCodeNameIndex = CODE_NAME_INDEX_UNKNOWN;
+
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p MaybeDispatchKeyEventAsProcessedByIME("
+               "aFollowingEvent=%s), dispatch fake eKeyDown event",
+               this, ToChar(aFollowingEvent)));
+
+      KeymapWrapper::DispatchKeyDownOrKeyUpEvent(
+          lastFocusedWindow, fakeKeyDownEvent, &mKeyboardEventWasConsumed);
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   MaybeDispatchKeyEventAsProcessedByIME(), "
+               "fake keydown event is dispatched",
+               this));
+    }
+  }
+
+  if (lastFocusedWindow->IsDestroyed() ||
+      lastFocusedWindow != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   MaybeDispatchKeyEventAsProcessedByIME(), Warning, the "
+             "focused widget was destroyed/changed by a key event",
+             this));
+    return false;
+  }
+
+  // If the dispatched keydown event caused moving focus and that also
+  // caused changing active context, we need to cancel composition here.
+  if (GetCurrentContext() != oldCurrentContext) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   MaybeDispatchKeyEventAsProcessedByIME(), Warning, the key "
+             "event causes changing active IM context",
+             this));
+    if (mComposingContext == oldComposingContext) {
+      // Only when the context is still composing, we should call
+      // ResetIME() here.  Otherwise, it should've already been
+      // cleaned up.
+      ResetIME();
+    }
+    return false;
+  }
+
+  return true;
+}
+
+bool IMContextWrapper::DispatchCompositionStart(GtkIMContext* aContext) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p DispatchCompositionStart(aContext=0x%p)", this, aContext));
+
+  if (IsComposing()) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionStart(), FAILED, "
+             "we're already in composition",
+             this));
+    return true;
+  }
+
+  if (!mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionStart(), FAILED, "
+             "there are no focused window in this module",
+             this));
+    return false;
+  }
+
+  if (NS_WARN_IF(!EnsureToCacheContentSelection())) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionStart(), FAILED, "
+             "cannot query the selection offset",
+             this));
+    return false;
+  }
+
+  if (NS_WARN_IF(!mContentSelection->HasRange())) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionStart(), FAILED, "
+             "due to no selection",
+             this));
+    return false;
+  }
+
+  mComposingContext = static_cast<GtkIMContext*>(g_object_ref(aContext));
+  MOZ_ASSERT(mComposingContext);
+
+  // Keep the last focused window alive
+  RefPtr<nsWindow> lastFocusedWindow(mLastFocusedWindow);
+
+  // XXX The composition start point might be changed by composition events
+  //     even though we strongly hope it doesn't happen.
+  //     Every composition event should have the start offset for the result
+  //     because it may high cost if we query the offset every time.
+  mCompositionStart = mContentSelection->OffsetAndDataRef().StartOffset();
+  mDispatchedCompositionString.Truncate();
+
+  // If this composition is started by a key press, we need to dispatch
+  // eKeyDown or eKeyUp event before dispatching eCompositionStart event.
+  // Note that dispatching a keyboard event which is marked as "processed
+  // by IME" is okay since Chromium also dispatches keyboard event as so.
+  if (!MaybeDispatchKeyEventAsProcessedByIME(eCompositionStart)) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   DispatchCompositionStart(), Warning, "
+             "MaybeDispatchKeyEventAsProcessedByIME() returned false",
+             this));
+    return false;
+  }
+
+  RefPtr<TextEventDispatcher> dispatcher = GetTextEventDispatcher();
+  nsresult rv = dispatcher->BeginNativeInputTransaction();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionStart(), FAILED, "
+             "due to BeginNativeInputTransaction() failure",
+             this));
+    return false;
+  }
+
+  static bool sHasSetTelemetry = false;
+  if (!sHasSetTelemetry) {
+    sHasSetTelemetry = true;
+    NS_ConvertUTF8toUTF16 im(GetIMName());
+    // 72 is kMaximumKeyStringLength in TelemetryScalar.cpp
+    if (im.Length() > 72) {
+      if (NS_IS_SURROGATE_PAIR(im[72 - 2], im[72 - 1])) {
+        im.Truncate(72 - 2);
+      } else {
+        im.Truncate(72 - 1);
+      }
+      // U+2026 is "..."
+      im.Append(char16_t(0x2026));
+    }
+    Telemetry::ScalarSet(Telemetry::ScalarID::WIDGET_IME_NAME_ON_LINUX, im,
+                         true);
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Debug,
+          ("0x%p   DispatchCompositionStart(), dispatching "
+           "compositionstart... (mCompositionStart=%u)",
+           this, mCompositionStart));
+  mCompositionState = eCompositionState_CompositionStartDispatched;
+  nsEventStatus status;
+  dispatcher->StartComposition(status);
+  if (lastFocusedWindow->IsDestroyed() ||
+      lastFocusedWindow != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionStart(), FAILED, the focused "
+             "widget was destroyed/changed by compositionstart event",
+             this));
+    return false;
+  }
+
+  return true;
+}
+
+bool IMContextWrapper::DispatchCompositionChangeEvent(
+    GtkIMContext* aContext, const nsAString& aCompositionString) {
+  MOZ_LOG(
+      gIMELog, LogLevel::Info,
+      ("0x%p DispatchCompositionChangeEvent(aContext=0x%p)", this, aContext));
+
+  if (!mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionChangeEvent(), FAILED, "
+             "there are no focused window in this module",
+             this));
+    return false;
+  }
+
+  if (!IsComposing()) {
+    MOZ_LOG(gIMELog, LogLevel::Debug,
+            ("0x%p   DispatchCompositionChangeEvent(), the composition "
+             "wasn't started, force starting...",
+             this));
+    if (!DispatchCompositionStart(aContext)) {
+      return false;
+    }
+  }
+  // If this composition string change caused by a key press, we need to
+  // dispatch eKeyDown or eKeyUp before dispatching eCompositionChange event.
+  else if (!MaybeDispatchKeyEventAsProcessedByIME(eCompositionChange)) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   DispatchCompositionChangeEvent(), Warning, "
+             "MaybeDispatchKeyEventAsProcessedByIME() returned false",
+             this));
+    return false;
+  }
+
+  RefPtr<TextEventDispatcher> dispatcher = GetTextEventDispatcher();
+  nsresult rv = dispatcher->BeginNativeInputTransaction();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionChangeEvent(), FAILED, "
+             "due to BeginNativeInputTransaction() failure",
+             this));
+    return false;
+  }
+
+  // Store the selected string which will be removed by following
+  // compositionchange event.
+  if (mCompositionState == eCompositionState_CompositionStartDispatched) {
+    if (NS_WARN_IF(!EnsureToCacheContentSelection(
+            &mSelectedStringRemovedByComposition))) {
+      // XXX How should we behave in this case??
+    } else if (mContentSelection->HasRange()) {
+      // XXX We should assume, for now, any web applications don't change
+      //     selection at handling this compositionchange event.
+      mCompositionStart = mContentSelection->OffsetAndDataRef().StartOffset();
+    } else {
+      // If there is no selection range, we should keep previously storing
+      // mCompositionStart.
+    }
+  }
+
+  RefPtr<TextRangeArray> rangeArray =
+      CreateTextRangeArray(aContext, aCompositionString);
+
+  rv = dispatcher->SetPendingComposition(aCompositionString, rangeArray);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionChangeEvent(), FAILED, "
+             "due to SetPendingComposition() failure",
+             this));
+    return false;
+  }
+
+  mCompositionState = eCompositionState_CompositionChangeEventDispatched;
+
+  // We cannot call SetCursorPosition for e10s-aware.
+  // DispatchEvent is async on e10s, so composition rect isn't updated now
+  // on tab parent.
+  mDispatchedCompositionString = aCompositionString;
+  mLayoutChanged = false;
+  mCompositionTargetRange.mOffset =
+      mCompositionStart + rangeArray->TargetClauseOffset();
+  mCompositionTargetRange.mLength = rangeArray->TargetClauseLength();
+
+  RefPtr<nsWindow> lastFocusedWindow(mLastFocusedWindow);
+  nsEventStatus status;
+  rv = dispatcher->FlushPendingComposition(status);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionChangeEvent(), FAILED, "
+             "due to FlushPendingComposition() failure",
+             this));
+    return false;
+  }
+
+  if (lastFocusedWindow->IsDestroyed() ||
+      lastFocusedWindow != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionChangeEvent(), FAILED, the "
+             "focused widget was destroyed/changed by "
+             "compositionchange event",
+             this));
+    return false;
+  }
+  return true;
+}
+
+bool IMContextWrapper::DispatchCompositionCommitEvent(
+    GtkIMContext* aContext, const nsAString* aCommitString) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p DispatchCompositionCommitEvent(aContext=0x%p, "
+           "aCommitString=0x%p, (\"%s\"))",
+           this, aContext, aCommitString,
+           aCommitString ? NS_ConvertUTF16toUTF8(*aCommitString).get() : ""));
+
+  if (!mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionCommitEvent(), FAILED, "
+             "there are no focused window in this module",
+             this));
+    return false;
+  }
+
+  // TODO: We need special care to handle request to commit composition
+  //       by content while we're committing composition because we have
+  //       commit string information now but IME may not have composition
+  //       anymore.  Therefore, we may not be able to handle commit as
+  //       expected.  However, this is rare case because this situation
+  //       never occurs with remote content.  So, it's okay to fix this
+  //       issue later.  (Perhaps, TextEventDisptcher should do it for
+  //       all platforms.  E.g., creating WillCommitComposition()?)
+  RefPtr<nsWindow> lastFocusedWindow(mLastFocusedWindow);
+  RefPtr<TextEventDispatcher> dispatcher;
+  if (!IsComposing() &&
+      !StaticPrefs::intl_ime_use_composition_events_for_insert_text()) {
+    if (!aCommitString || aCommitString->IsEmpty()) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   DispatchCompositionCommitEvent(), FAILED, "
+               "did nothing due to inserting empty string without composition",
+               this));
+      return true;
+    }
+    if (MOZ_UNLIKELY(!EnsureToCacheContentSelection())) {
+      MOZ_LOG(gIMELog, LogLevel::Warning,
+              ("0x%p   DispatchCompositionCommitEvent(), Warning, "
+               "Failed to cache selection before dispatching "
+               "eContentCommandInsertText event",
+               this));
+    }
+    if (!MaybeDispatchKeyEventAsProcessedByIME(eContentCommandInsertText)) {
+      MOZ_LOG(gIMELog, LogLevel::Warning,
+              ("0x%p   DispatchCompositionCommitEvent(), Warning, "
+               "MaybeDispatchKeyEventAsProcessedByIME() returned false",
+               this));
+      return false;
+    }
+    // Emulate selection until receiving actual selection range.  This is
+    // important for OnSelectionChange.  If selection is not changed by web
+    // apps, i.e., selection range is same as what selection expects, we
+    // shouldn't reset IME because the trigger of causing this commit may be an
+    // input for next composition and we shouldn't cancel it.
+    if (mContentSelection.isSome()) {
+      mContentSelection->Collapse(
+          (mContentSelection->HasRange()
+               ? mContentSelection->OffsetAndDataRef().StartOffset()
+               : mCompositionStart) +
+          aCommitString->Length());
+      MOZ_LOG(gIMELog, LogLevel::Info,
+              ("0x%p   DispatchCompositionCommitEvent(), mContentSelection=%s",
+               this, ToString(mContentSelection).c_str()));
+    }
+    MOZ_ASSERT(!dispatcher);
+  } else {
+    if (!IsComposing()) {
+      if (!aCommitString || aCommitString->IsEmpty()) {
+        MOZ_LOG(gIMELog, LogLevel::Error,
+                ("0x%p   DispatchCompositionCommitEvent(), FAILED, "
+                 "there is no composition and empty commit string",
+                 this));
+        return true;
+      }
+      MOZ_LOG(gIMELog, LogLevel::Debug,
+              ("0x%p   DispatchCompositionCommitEvent(), "
+               "the composition wasn't started, force starting...",
+               this));
+      if (!DispatchCompositionStart(aContext)) {
+        return false;
+      }
+    }
+    // If this commit caused by a key press, we need to dispatch eKeyDown or
+    // eKeyUp before dispatching composition events.
+    else if (!MaybeDispatchKeyEventAsProcessedByIME(
+                 aCommitString ? eCompositionCommit : eCompositionCommitAsIs)) {
+      MOZ_LOG(gIMELog, LogLevel::Warning,
+              ("0x%p   DispatchCompositionCommitEvent(), Warning, "
+               "MaybeDispatchKeyEventAsProcessedByIME() returned false",
+               this));
+      mCompositionState = eCompositionState_NotComposing;
+      return false;
+    }
+
+    dispatcher = GetTextEventDispatcher();
+    MOZ_ASSERT(dispatcher);
+    nsresult rv = dispatcher->BeginNativeInputTransaction();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   DispatchCompositionCommitEvent(), FAILED, "
+               "due to BeginNativeInputTransaction() failure",
+               this));
+      return false;
+    }
+
+    // Emulate selection until receiving actual selection range.
+    const uint32_t offsetToPutCaret =
+        mCompositionStart + (aCommitString
+                                 ? aCommitString->Length()
+                                 : mDispatchedCompositionString.Length());
+    if (mContentSelection.isSome()) {
+      mContentSelection->Collapse(offsetToPutCaret);
+    } else {
+      // TODO: We should guarantee that there should be at least fake selection
+      //       for IME at here.  Then, we can keep the last writing mode.
+      mContentSelection.emplace(offsetToPutCaret, WritingMode());
+    }
+  }
+
+  mCompositionState = eCompositionState_NotComposing;
+  // Reset dead key sequence too because GTK doesn't support dead key chain
+  // (i.e., a key press doesn't cause both producing some characters and
+  // restarting new dead key sequence at one time).  So, committing
+  // composition means end of a dead key sequence.
+  mMaybeInDeadKeySequence = false;
+  mCompositionStart = UINT32_MAX;
+  mCompositionTargetRange.Clear();
+  mDispatchedCompositionString.Truncate();
+  mSelectedStringRemovedByComposition.Truncate();
+
+  if (!dispatcher) {
+    MOZ_ASSERT(aCommitString);
+    MOZ_ASSERT(!aCommitString->IsEmpty());
+    nsEventStatus status = nsEventStatus_eIgnore;
+    WidgetContentCommandEvent insertTextEvent(true, eContentCommandInsertText,
+                                              lastFocusedWindow);
+    insertTextEvent.mString.emplace(*aCommitString);
+    lastFocusedWindow->DispatchEvent(&insertTextEvent, status);
+
+    if (!insertTextEvent.mSucceeded) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   DispatchCompositionChangeEvent(), FAILED, inserting "
+               "text failed",
+               this));
+      return false;
+    }
+  } else {
+    nsEventStatus status = nsEventStatus_eIgnore;
+    nsresult rv = dispatcher->CommitComposition(status, aCommitString);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   DispatchCompositionChangeEvent(), FAILED, "
+               "due to CommitComposition() failure",
+               this));
+      return false;
+    }
+  }
+
+  if (lastFocusedWindow->IsDestroyed() ||
+      lastFocusedWindow != mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DispatchCompositionCommitEvent(), FAILED, "
+             "the focused widget was destroyed/changed by "
+             "compositioncommit event",
+             this));
+    return false;
+  }
+
+  return true;
+}
+
+already_AddRefed<TextRangeArray> IMContextWrapper::CreateTextRangeArray(
+    GtkIMContext* aContext, const nsAString& aCompositionString) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p CreateTextRangeArray(aContext=0x%p, "
+           "aCompositionString=\"%s\" (Length()=%zu))",
+           this, aContext, NS_ConvertUTF16toUTF8(aCompositionString).get(),
+           aCompositionString.Length()));
+
+  RefPtr<TextRangeArray> textRangeArray = new TextRangeArray();
+
+  gchar* preedit_string;
+  gint cursor_pos_in_chars;
+  PangoAttrList* feedback_list;
+  gtk_im_context_get_preedit_string(aContext, &preedit_string, &feedback_list,
+                                    &cursor_pos_in_chars);
+  if (!preedit_string || !*preedit_string) {
+    if (!aCompositionString.IsEmpty()) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   CreateTextRangeArray(), FAILED, due to "
+               "preedit_string is null",
+               this));
+    }
+    pango_attr_list_unref(feedback_list);
+    g_free(preedit_string);
+    return textRangeArray.forget();
+  }
+
+  // Convert caret offset from offset in characters to offset in UTF-16
+  // string.  If we couldn't proper offset in UTF-16 string, we should
+  // assume that the caret is at the end of the composition string.
+  uint32_t caretOffsetInUTF16 = aCompositionString.Length();
+  if (NS_WARN_IF(cursor_pos_in_chars < 0)) {
+    // Note that this case is undocumented.  We should assume that the
+    // caret is at the end of the composition string.
+  } else if (cursor_pos_in_chars == 0) {
+    caretOffsetInUTF16 = 0;
+  } else {
+    gchar* charAfterCaret =
+        g_utf8_offset_to_pointer(preedit_string, cursor_pos_in_chars);
+    if (NS_WARN_IF(!charAfterCaret)) {
+      MOZ_LOG(gIMELog, LogLevel::Warning,
+              ("0x%p   CreateTextRangeArray(), failed to get UTF-8 "
+               "string before the caret (cursor_pos_in_chars=%d)",
+               this, cursor_pos_in_chars));
+    } else {
+      glong caretOffset = 0;
+      gunichar2* utf16StrBeforeCaret =
+          g_utf8_to_utf16(preedit_string, charAfterCaret - preedit_string,
+                          nullptr, &caretOffset, nullptr);
+      if (NS_WARN_IF(!utf16StrBeforeCaret) || NS_WARN_IF(caretOffset < 0)) {
+        MOZ_LOG(gIMELog, LogLevel::Warning,
+                ("0x%p   CreateTextRangeArray(), WARNING, failed to "
+                 "convert to UTF-16 string before the caret "
+                 "(cursor_pos_in_chars=%d, caretOffset=%ld)",
+                 this, cursor_pos_in_chars, caretOffset));
+      } else {
+        caretOffsetInUTF16 = static_cast<uint32_t>(caretOffset);
+        uint32_t compositionStringLength = aCompositionString.Length();
+        if (NS_WARN_IF(caretOffsetInUTF16 > compositionStringLength)) {
+          MOZ_LOG(gIMELog, LogLevel::Warning,
+                  ("0x%p   CreateTextRangeArray(), WARNING, "
+                   "caretOffsetInUTF16=%u is larger than "
+                   "compositionStringLength=%u",
+                   this, caretOffsetInUTF16, compositionStringLength));
+          caretOffsetInUTF16 = compositionStringLength;
+        }
+      }
+      if (utf16StrBeforeCaret) {
+        g_free(utf16StrBeforeCaret);
+      }
+    }
+  }
+
+  PangoAttrIterator* iter;
+  iter = pango_attr_list_get_iterator(feedback_list);
+  if (!iter) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   CreateTextRangeArray(), FAILED, iterator couldn't "
+             "be allocated",
+             this));
+    pango_attr_list_unref(feedback_list);
+    g_free(preedit_string);
+    return textRangeArray.forget();
+  }
+
+  uint32_t minOffsetOfClauses = aCompositionString.Length();
+  uint32_t maxOffsetOfClauses = 0;
+  do {
+    TextRange range;
+    if (!SetTextRange(iter, preedit_string, caretOffsetInUTF16, range)) {
+      continue;
+    }
+    MOZ_ASSERT(range.Length());
+    minOffsetOfClauses = std::min(minOffsetOfClauses, range.mStartOffset);
+    maxOffsetOfClauses = std::max(maxOffsetOfClauses, range.mEndOffset);
+    textRangeArray->AppendElement(range);
+  } while (pango_attr_iterator_next(iter));
+
+  // If the IME doesn't define clause from the start of the composition,
+  // we should insert dummy clause information since TextRangeArray assumes
+  // that there must be a clause whose start is 0 when there is one or
+  // more clauses.
+  if (minOffsetOfClauses) {
+    TextRange dummyClause;
+    dummyClause.mStartOffset = 0;
+    dummyClause.mEndOffset = minOffsetOfClauses;
+    dummyClause.mRangeType = TextRangeType::eRawClause;
+    textRangeArray->InsertElementAt(0, dummyClause);
+    maxOffsetOfClauses = std::max(maxOffsetOfClauses, dummyClause.mEndOffset);
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   CreateTextRangeArray(), inserting a dummy clause "
+             "at the beginning of the composition string mStartOffset=%u, "
+             "mEndOffset=%u, mRangeType=%s",
+             this, dummyClause.mStartOffset, dummyClause.mEndOffset,
+             ToChar(dummyClause.mRangeType)));
+  }
+
+  // If the IME doesn't define clause at end of the composition, we should
+  // insert dummy clause information since TextRangeArray assumes that there
+  // must be a clase whose end is the length of the composition string when
+  // there is one or more clauses.
+  if (!textRangeArray->IsEmpty() &&
+      maxOffsetOfClauses < aCompositionString.Length()) {
+    TextRange dummyClause;
+    dummyClause.mStartOffset = maxOffsetOfClauses;
+    dummyClause.mEndOffset = aCompositionString.Length();
+    dummyClause.mRangeType = TextRangeType::eRawClause;
+    textRangeArray->AppendElement(dummyClause);
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   CreateTextRangeArray(), inserting a dummy clause "
+             "at the end of the composition string mStartOffset=%u, "
+             "mEndOffset=%u, mRangeType=%s",
+             this, dummyClause.mStartOffset, dummyClause.mEndOffset,
+             ToChar(dummyClause.mRangeType)));
+  }
+
+  TextRange range;
+  range.mStartOffset = range.mEndOffset = caretOffsetInUTF16;
+  range.mRangeType = TextRangeType::eCaret;
+  textRangeArray->AppendElement(range);
+  MOZ_LOG(
+      gIMELog, LogLevel::Debug,
+      ("0x%p   CreateTextRangeArray(), mStartOffset=%u, "
+       "mEndOffset=%u, mRangeType=%s",
+       this, range.mStartOffset, range.mEndOffset, ToChar(range.mRangeType)));
+
+  pango_attr_iterator_destroy(iter);
+  pango_attr_list_unref(feedback_list);
+  g_free(preedit_string);
+
+  return textRangeArray.forget();
+}
+
+/* static */
+nscolor IMContextWrapper::ToNscolor(PangoAttrColor* aPangoAttrColor) {
+  PangoColor& pangoColor = aPangoAttrColor->color;
+  uint8_t r = pangoColor.red / 0x100;
+  uint8_t g = pangoColor.green / 0x100;
+  uint8_t b = pangoColor.blue / 0x100;
+  return NS_RGB(r, g, b);
+}
+
+bool IMContextWrapper::SetTextRange(PangoAttrIterator* aPangoAttrIter,
+                                    const gchar* aUTF8CompositionString,
+                                    uint32_t aUTF16CaretOffset,
+                                    TextRange& aTextRange) const {
+  // Set the range offsets in UTF-16 string.
+  gint utf8ClauseStart, utf8ClauseEnd;
+  pango_attr_iterator_range(aPangoAttrIter, &utf8ClauseStart, &utf8ClauseEnd);
+  if (utf8ClauseStart == utf8ClauseEnd) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetTextRange(), FAILED, due to collapsed range", this));
+    return false;
+  }
+
+  if (!utf8ClauseStart) {
+    aTextRange.mStartOffset = 0;
+  } else {
+    glong utf16PreviousClausesLength;
+    gunichar2* utf16PreviousClausesString =
+        g_utf8_to_utf16(aUTF8CompositionString, utf8ClauseStart, nullptr,
+                        &utf16PreviousClausesLength, nullptr);
+
+    if (NS_WARN_IF(!utf16PreviousClausesString)) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   SetTextRange(), FAILED, due to g_utf8_to_utf16() "
+               "failure (retrieving previous string of current clause)",
+               this));
+      return false;
+    }
+
+    aTextRange.mStartOffset = utf16PreviousClausesLength;
+    g_free(utf16PreviousClausesString);
+  }
+
+  glong utf16CurrentClauseLength;
+  gunichar2* utf16CurrentClauseString = g_utf8_to_utf16(
+      aUTF8CompositionString + utf8ClauseStart, utf8ClauseEnd - utf8ClauseStart,
+      nullptr, &utf16CurrentClauseLength, nullptr);
+
+  if (NS_WARN_IF(!utf16CurrentClauseString)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetTextRange(), FAILED, due to g_utf8_to_utf16() "
+             "failure (retrieving current clause)",
+             this));
+    return false;
+  }
+
+  // iBus Chewing IME tells us that there is an empty clause at the end of
+  // the composition string but we should ignore it since our code doesn't
+  // assume that there is an empty clause.
+  if (!utf16CurrentClauseLength) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   SetTextRange(), FAILED, due to current clause length "
+             "is 0",
+             this));
+    return false;
+  }
+
+  aTextRange.mEndOffset = aTextRange.mStartOffset + utf16CurrentClauseLength;
+  g_free(utf16CurrentClauseString);
+  utf16CurrentClauseString = nullptr;
+
+  // Set styles
+  TextRangeStyle& style = aTextRange.mRangeStyle;
+
+  // Underline
+  PangoAttrInt* attrUnderline = reinterpret_cast<PangoAttrInt*>(
+      pango_attr_iterator_get(aPangoAttrIter, PANGO_ATTR_UNDERLINE));
+  if (attrUnderline) {
+    switch (attrUnderline->value) {
+      case PANGO_UNDERLINE_NONE:
+        style.mLineStyle = TextRangeStyle::LineStyle::None;
+        break;
+      case PANGO_UNDERLINE_DOUBLE:
+        style.mLineStyle = TextRangeStyle::LineStyle::Double;
+        break;
+      case PANGO_UNDERLINE_ERROR:
+        style.mLineStyle = TextRangeStyle::LineStyle::Wavy;
+        break;
+      case PANGO_UNDERLINE_SINGLE:
+      case PANGO_UNDERLINE_LOW:
+        style.mLineStyle = TextRangeStyle::LineStyle::Solid;
+        break;
+      default:
+        MOZ_LOG(gIMELog, LogLevel::Warning,
+                ("0x%p   SetTextRange(), retrieved unknown underline "
+                 "style: %d",
+                 this, attrUnderline->value));
+        style.mLineStyle = TextRangeStyle::LineStyle::Solid;
+        break;
+    }
+    style.mDefinedStyles |= TextRangeStyle::DEFINED_LINESTYLE;
+
+    // Underline color
+    PangoAttrColor* attrUnderlineColor = reinterpret_cast<PangoAttrColor*>(
+        pango_attr_iterator_get(aPangoAttrIter, PANGO_ATTR_UNDERLINE_COLOR));
+    if (attrUnderlineColor) {
+      style.mUnderlineColor = ToNscolor(attrUnderlineColor);
+      style.mDefinedStyles |= TextRangeStyle::DEFINED_UNDERLINE_COLOR;
+    }
+  } else {
+    style.mLineStyle = TextRangeStyle::LineStyle::None;
+    style.mDefinedStyles |= TextRangeStyle::DEFINED_LINESTYLE;
+  }
+
+  // Don't set colors if they are not specified.  They should be computed by
+  // textframe if only one of the colors are specified.
+
+  // Foreground color (text color)
+  PangoAttrColor* attrForeground = reinterpret_cast<PangoAttrColor*>(
+      pango_attr_iterator_get(aPangoAttrIter, PANGO_ATTR_FOREGROUND));
+  if (attrForeground) {
+    style.mForegroundColor = ToNscolor(attrForeground);
+    style.mDefinedStyles |= TextRangeStyle::DEFINED_FOREGROUND_COLOR;
+  }
+
+  // Background color
+  PangoAttrColor* attrBackground = reinterpret_cast<PangoAttrColor*>(
+      pango_attr_iterator_get(aPangoAttrIter, PANGO_ATTR_BACKGROUND));
+  if (attrBackground) {
+    style.mBackgroundColor = ToNscolor(attrBackground);
+    style.mDefinedStyles |= TextRangeStyle::DEFINED_BACKGROUND_COLOR;
+  }
+
+  /**
+   * We need to judge the meaning of the clause for a11y.  Before we support
+   * IME specific composition string style, we used following rules:
+   *
+   *   1: If attrUnderline and attrForground are specified, we assumed the
+   *      clause is TextRangeType::eSelectedClause.
+   *   2: If only attrUnderline is specified, we assumed the clause is
+   *      TextRangeType::eConvertedClause.
+   *   3: If only attrForground is specified, we assumed the clause is
+   *      TextRangeType::eSelectedRawClause.
+   *   4: If neither attrUnderline nor attrForeground is specified, we assumed
+   *      the clause is TextRangeType::eRawClause.
+   *
+   * However, this rules are odd since there can be two or more selected
+   * clauses.  Additionally, our old rules caused that IME developers/users
+   * cannot specify composition string style as they want.
+   *
+   * So, we shouldn't guess the meaning from its visual style.
+   */
+
+  // If the range covers whole of composition string and the caret is at
+  // the end of the composition string, the range is probably not converted.
+  if (!utf8ClauseStart &&
+      utf8ClauseEnd == static_cast<gint>(strlen(aUTF8CompositionString)) &&
+      aTextRange.mEndOffset == aUTF16CaretOffset) {
+    aTextRange.mRangeType = TextRangeType::eRawClause;
+  }
+  // Typically, the caret is set at the start of the selected clause.
+  // So, if the caret is in the clause, we can assume that the clause is
+  // selected.
+  else if (aTextRange.mStartOffset <= aUTF16CaretOffset &&
+           aTextRange.mEndOffset > aUTF16CaretOffset) {
+    aTextRange.mRangeType = TextRangeType::eSelectedClause;
+  }
+  // Otherwise, we should assume that the clause is converted but not
+  // selected.
+  else {
+    aTextRange.mRangeType = TextRangeType::eConvertedClause;
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Debug,
+          ("0x%p   SetTextRange(), succeeded, aTextRange= { "
+           "mStartOffset=%u, mEndOffset=%u, mRangeType=%s, mRangeStyle=%s }",
+           this, aTextRange.mStartOffset, aTextRange.mEndOffset,
+           ToChar(aTextRange.mRangeType),
+           GetTextRangeStyleText(aTextRange.mRangeStyle).get()));
+
+  return true;
+}
+
+void IMContextWrapper::SetCursorPosition(GtkIMContext* aContext) {
+  MOZ_LOG(
+      gIMELog, LogLevel::Info,
+      ("0x%p SetCursorPosition(aContext=0x%p), "
+       "mCompositionTargetRange={ mOffset=%u, mLength=%u }, "
+       "mContentSelection=%s",
+       this, aContext, mCompositionTargetRange.mOffset,
+       mCompositionTargetRange.mLength, ToString(mContentSelection).c_str()));
+
+  bool useCaret = false;
+  if (!mCompositionTargetRange.IsValid()) {
+    if (mContentSelection.isNothing()) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   SetCursorPosition(), FAILED, "
+               "mCompositionTargetRange and mContentSelection are invalid",
+               this));
+      return;
+    }
+    if (!mContentSelection->HasRange()) {
+      MOZ_LOG(gIMELog, LogLevel::Warning,
+              ("0x%p   SetCursorPosition(), FAILED, "
+               "mCompositionTargetRange is invalid and there is no selection",
+               this));
+      return;
+    }
+    useCaret = true;
+  }
+
+  if (!mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetCursorPosition(), FAILED, due to no focused "
+             "window",
+             this));
+    return;
+  }
+
+  if (MOZ_UNLIKELY(!aContext)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetCursorPosition(), FAILED, due to no context", this));
+    return;
+  }
+
+  WidgetQueryContentEvent queryCaretOrTextRectEvent(
+      true, useCaret ? eQueryCaretRect : eQueryTextRect, mLastFocusedWindow);
+  if (useCaret) {
+    queryCaretOrTextRectEvent.InitForQueryCaretRect(
+        mContentSelection->OffsetAndDataRef().StartOffset());
+  } else {
+    if (mContentSelection->WritingModeRef().IsVertical()) {
+      // For preventing the candidate window to overlap the target
+      // clause, we should set fake (typically, very tall) caret rect.
+      uint32_t length =
+          mCompositionTargetRange.mLength ? mCompositionTargetRange.mLength : 1;
+      queryCaretOrTextRectEvent.InitForQueryTextRect(
+          mCompositionTargetRange.mOffset, length);
+    } else {
+      queryCaretOrTextRectEvent.InitForQueryTextRect(
+          mCompositionTargetRange.mOffset, 1);
+    }
+  }
+  nsEventStatus status;
+  mLastFocusedWindow->DispatchEvent(&queryCaretOrTextRectEvent, status);
+  if (queryCaretOrTextRectEvent.Failed()) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   SetCursorPosition(), FAILED, %s was failed", this,
+             useCaret ? "eQueryCaretRect" : "eQueryTextRect"));
+    return;
+  }
+
+  nsWindow* rootWindow =
+      static_cast<nsWindow*>(mLastFocusedWindow->GetTopLevelWidget());
+
+  // Get the position of the rootWindow in screen.
+  LayoutDeviceIntPoint root = rootWindow->WidgetToScreenOffset();
+
+  // Get the position of IM context owner window in screen.
+  LayoutDeviceIntPoint owner = mOwnerWindow->WidgetToScreenOffset();
+
+  // Compute the caret position in the IM owner window.
+  LayoutDeviceIntRect rect =
+      queryCaretOrTextRectEvent.mReply->mRect + root - owner;
+  rect.width = 0;
+  GdkRectangle area = rootWindow->DevicePixelsToGdkRectRoundOut(rect);
+
+  gtk_im_context_set_cursor_location(aContext, &area);
+}
+
+nsresult IMContextWrapper::GetCurrentParagraph(nsAString& aText,
+                                               uint32_t& aCursorPos) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p GetCurrentParagraph(), mCompositionState=%s", this,
+           GetCompositionStateName()));
+
+  if (!mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   GetCurrentParagraph(), FAILED, there are no "
+             "focused window in this module",
+             this));
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  nsEventStatus status;
+
+  uint32_t selOffset = mCompositionStart;
+  uint32_t selLength = mSelectedStringRemovedByComposition.Length();
+
+  // If focused editor doesn't have composition string, we should use
+  // current selection.
+  if (!EditorHasCompositionString()) {
+    // Query cursor position & selection
+    if (NS_WARN_IF(!EnsureToCacheContentSelection())) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   GetCurrentParagraph(), FAILED, due to no "
+               "valid selection information",
+               this));
+      return NS_ERROR_FAILURE;
+    }
+
+    if (mContentSelection.isSome() && mContentSelection->HasRange()) {
+      selOffset = mContentSelection->OffsetAndDataRef().StartOffset();
+      selLength = mContentSelection->OffsetAndDataRef().Length();
+    } else {
+      // If there is no range, let's get all text instead...
+      selOffset = 0u;
+      selLength = INT32_MAX;  // TODO: Change to UINT32_MAX, but see below
+    }
+  }
+
+  MOZ_LOG(gIMELog, LogLevel::Debug,
+          ("0x%p   GetCurrentParagraph(), selOffset=%u, selLength=%u", this,
+           selOffset, selLength));
+
+  // XXX nsString::Find and nsString::RFind take int32_t for offset, so,
+  //     we cannot support this request when the current offset is larger
+  //     than INT32_MAX.
+  if (selOffset > INT32_MAX || selLength > INT32_MAX ||
+      selOffset + selLength > INT32_MAX) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   GetCurrentParagraph(), FAILED, The selection is "
+             "out of range",
+             this));
+    return NS_ERROR_FAILURE;
+  }
+
+  // Get all text contents of the focused editor
+  WidgetQueryContentEvent queryTextContentEvent(true, eQueryTextContent,
+                                                mLastFocusedWindow);
+  queryTextContentEvent.InitForQueryTextContent(0, UINT32_MAX);
+  mLastFocusedWindow->DispatchEvent(&queryTextContentEvent, status);
+  if (NS_WARN_IF(queryTextContentEvent.Failed())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (selOffset + selLength > queryTextContentEvent.mReply->DataLength()) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   GetCurrentParagraph(), FAILED, The selection is "
+             "invalid, queryTextContentEvent={ mReply=%s }",
+             this, ToString(queryTextContentEvent.mReply).c_str()));
+    return NS_ERROR_FAILURE;
+  }
+
+  // Remove composing string and restore the selected string because
+  // GtkEntry doesn't remove selected string until committing, however,
+  // our editor does it.  We should emulate the behavior for IME.
+  nsAutoString textContent(queryTextContentEvent.mReply->DataRef());
+  if (EditorHasCompositionString() &&
+      mDispatchedCompositionString != mSelectedStringRemovedByComposition) {
+    textContent.Replace(mCompositionStart,
+                        mDispatchedCompositionString.Length(),
+                        mSelectedStringRemovedByComposition);
+  }
+
+  // Get only the focused paragraph, by looking for newlines
+  int32_t parStart = 0;
+  if (selOffset > 0) {
+    parStart = Substring(textContent, 0, selOffset - 1).RFind(u"\n") + 1;
+  }
+  int32_t parEnd = textContent.Find(u"\n", selOffset + selLength);
+  if (parEnd < 0) {
+    parEnd = textContent.Length();
+  }
+  aText = nsDependentSubstring(textContent, parStart, parEnd - parStart);
+  aCursorPos = selOffset - uint32_t(parStart);
+
+  MOZ_LOG(
+      gIMELog, LogLevel::Debug,
+      ("0x%p   GetCurrentParagraph(), succeeded, aText=%s, "
+       "aText.Length()=%zu, aCursorPos=%u",
+       this, NS_ConvertUTF16toUTF8(aText).get(), aText.Length(), aCursorPos));
+
+  return NS_OK;
+}
+
+nsresult IMContextWrapper::DeleteText(GtkIMContext* aContext, int32_t aOffset,
+                                      uint32_t aNChars) {
+  MOZ_LOG(gIMELog, LogLevel::Info,
+          ("0x%p DeleteText(aContext=0x%p, aOffset=%d, aNChars=%u), "
+           "mCompositionState=%s",
+           this, aContext, aOffset, aNChars, GetCompositionStateName()));
+
+  if (!mLastFocusedWindow) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, there are no focused window "
+             "in this module",
+             this));
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  if (!aNChars) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, aNChars must not be zero", this));
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<nsWindow> lastFocusedWindow(mLastFocusedWindow);
+  nsEventStatus status;
+
+  // First, we should cancel current composition because editor cannot
+  // handle changing selection and deleting text.
+  uint32_t selOffset;
+  bool wasComposing = IsComposing();
+  bool editorHadCompositionString = EditorHasCompositionString();
+  if (wasComposing) {
+    selOffset = mCompositionStart;
+    if (!DispatchCompositionCommitEvent(aContext,
+                                        &mSelectedStringRemovedByComposition)) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   DeleteText(), FAILED, quitting from DeletText", this));
+      return NS_ERROR_FAILURE;
+    }
+  } else {
+    if (NS_WARN_IF(!EnsureToCacheContentSelection())) {
+      MOZ_LOG(gIMELog, LogLevel::Error,
+              ("0x%p   DeleteText(), FAILED, due to no valid selection "
+               "information",
+               this));
+      return NS_ERROR_FAILURE;
+    }
+    if (!mContentSelection->HasRange()) {
+      MOZ_LOG(gIMELog, LogLevel::Debug,
+              ("0x%p   DeleteText(), does nothing, due to no selection range",
+               this));
+      return NS_OK;
+    }
+    selOffset = mContentSelection->OffsetAndDataRef().StartOffset();
+  }
+
+  // Get all text contents of the focused editor
+  WidgetQueryContentEvent queryTextContentEvent(true, eQueryTextContent,
+                                                mLastFocusedWindow);
+  queryTextContentEvent.InitForQueryTextContent(0, UINT32_MAX);
+  mLastFocusedWindow->DispatchEvent(&queryTextContentEvent, status);
+  if (NS_WARN_IF(queryTextContentEvent.Failed())) {
+    return NS_ERROR_FAILURE;
+  }
+  if (queryTextContentEvent.mReply->IsDataEmpty()) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, there is no contents", this));
+    return NS_ERROR_FAILURE;
+  }
+
+  NS_ConvertUTF16toUTF8 utf8Str(nsDependentSubstring(
+      queryTextContentEvent.mReply->DataRef(), 0, selOffset));
+  glong offsetInUTF8Characters =
+      g_utf8_strlen(utf8Str.get(), utf8Str.Length()) + aOffset;
+  if (offsetInUTF8Characters < 0) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, aOffset is too small for "
+             "current cursor pos (computed offset: %ld)",
+             this, offsetInUTF8Characters));
+    return NS_ERROR_FAILURE;
+  }
+
+  AppendUTF16toUTF8(
+      nsDependentSubstring(queryTextContentEvent.mReply->DataRef(), selOffset),
+      utf8Str);
+  glong countOfCharactersInUTF8 =
+      g_utf8_strlen(utf8Str.get(), utf8Str.Length());
+  glong endInUTF8Characters = offsetInUTF8Characters + aNChars;
+  if (countOfCharactersInUTF8 < endInUTF8Characters) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, aNChars is too large for "
+             "current contents (content length: %ld, computed end offset: %ld)",
+             this, countOfCharactersInUTF8, endInUTF8Characters));
+    return NS_ERROR_FAILURE;
+  }
+
+  gchar* charAtOffset =
+      g_utf8_offset_to_pointer(utf8Str.get(), offsetInUTF8Characters);
+  gchar* charAtEnd =
+      g_utf8_offset_to_pointer(utf8Str.get(), endInUTF8Characters);
+
+  // Set selection to delete
+  WidgetSelectionEvent selectionEvent(true, eSetSelection, mLastFocusedWindow);
+
+  nsDependentCSubstring utf8StrBeforeOffset(utf8Str, 0,
+                                            charAtOffset - utf8Str.get());
+  selectionEvent.mOffset = NS_ConvertUTF8toUTF16(utf8StrBeforeOffset).Length();
+
+  nsDependentCSubstring utf8DeletingStr(utf8Str, utf8StrBeforeOffset.Length(),
+                                        charAtEnd - charAtOffset);
+  selectionEvent.mLength = NS_ConvertUTF8toUTF16(utf8DeletingStr).Length();
+
+  selectionEvent.mReversed = false;
+  selectionEvent.mExpandToClusterBoundary = false;
+  lastFocusedWindow->DispatchEvent(&selectionEvent, status);
+
+  if (!selectionEvent.mSucceeded || lastFocusedWindow != mLastFocusedWindow ||
+      lastFocusedWindow->Destroyed()) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, setting selection caused "
+             "focus change or window destroyed",
+             this));
+    return NS_ERROR_FAILURE;
+  }
+
+  // If this deleting text caused by a key press, we need to dispatch
+  // eKeyDown or eKeyUp before dispatching eContentCommandDelete event.
+  if (!MaybeDispatchKeyEventAsProcessedByIME(eContentCommandDelete)) {
+    MOZ_LOG(gIMELog, LogLevel::Warning,
+            ("0x%p   DeleteText(), Warning, "
+             "MaybeDispatchKeyEventAsProcessedByIME() returned false",
+             this));
+    return NS_ERROR_FAILURE;
+  }
+
+  // Delete the selection
+  WidgetContentCommandEvent contentCommandEvent(true, eContentCommandDelete,
+                                                mLastFocusedWindow);
+  mLastFocusedWindow->DispatchEvent(&contentCommandEvent, status);
+
+  if (!contentCommandEvent.mSucceeded ||
+      lastFocusedWindow != mLastFocusedWindow ||
+      lastFocusedWindow->Destroyed()) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p   DeleteText(), FAILED, deleting the selection caused "
+             "focus change or window destroyed",
+             this));
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!wasComposing) {
+    return NS_OK;
+  }
+
+  // Restore the composition at new caret position.
+  if (!DispatchCompositionStart(aContext)) {
+    MOZ_LOG(
+        gIMELog, LogLevel::Error,
+        ("0x%p   DeleteText(), FAILED, resterting composition start", this));
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!editorHadCompositionString) {
+    return NS_OK;
+  }
+
+  nsAutoString compositionString;
+  GetCompositionString(aContext, compositionString);
+  if (!DispatchCompositionChangeEvent(aContext, compositionString)) {
+    MOZ_LOG(
+        gIMELog, LogLevel::Error,
+        ("0x%p   DeleteText(), FAILED, restoring composition string", this));
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+bool IMContextWrapper::EnsureToCacheContentSelection(
+    nsAString* aSelectedString) {
+  if (aSelectedString) {
+    aSelectedString->Truncate();
+  }
+
+  if (mContentSelection.isSome()) {
+    if (mContentSelection->HasRange() && aSelectedString) {
+      aSelectedString->Assign(mContentSelection->OffsetAndDataRef().DataRef());
+    }
+    return true;
+  }
+
+  RefPtr<nsWindow> dispatcherWindow =
+      mLastFocusedWindow ? mLastFocusedWindow : mOwnerWindow;
+  if (NS_WARN_IF(!dispatcherWindow)) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p EnsureToCacheContentSelection(), FAILED, due to "
+             "no focused window",
+             this));
+    return false;
+  }
+
+  nsEventStatus status;
+  WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
+                                                 dispatcherWindow);
+  dispatcherWindow->DispatchEvent(&querySelectedTextEvent, status);
+  if (NS_WARN_IF(querySelectedTextEvent.Failed())) {
+    MOZ_LOG(gIMELog, LogLevel::Error,
+            ("0x%p EnsureToCacheContentSelection(), FAILED, due to "
+             "failure of query selection event",
+             this));
+    return false;
+  }
+
+  mContentSelection = Some(ContentSelection(querySelectedTextEvent));
+  if (mContentSelection->HasRange()) {
+    if (!mContentSelection->OffsetAndDataRef().IsDataEmpty() &&
+        aSelectedString) {
+      aSelectedString->Assign(querySelectedTextEvent.mReply->DataRef());
+    }
+  }
+
+  MOZ_LOG(
+      gIMELog, LogLevel::Debug,
+      ("0x%p EnsureToCacheContentSelection(), Succeeded, mContentSelection=%s",
+       this, ToString(mContentSelection).c_str()));
+  return true;
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/IMContextWrapper.h b/widget/gtk/IMContextWrapper.h
new file mode 100644
index 0000000000..81fa861b22
--- /dev/null
+++ b/widget/gtk/IMContextWrapper.h
@@ -0,0 +1,672 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef IMContextWrapper_h_
+#define IMContextWrapper_h_
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "nsString.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+#include "nsIWidget.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/ContentData.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/TextEventDispatcherListener.h"
+#include "mozilla/WritingModes.h"
+#include "mozilla/GUniquePtr.h"
+#include "mozilla/widget/IMEData.h"
+
+class nsWindow;
+
+namespace mozilla {
+namespace widget {
+
+/**
+ * KeyHandlingState is result of IMContextWrapper::OnKeyEvent().
+ */
+enum class KeyHandlingState {
+  // The native key event has not been handled by IMContextWrapper.
+  eNotHandled,
+  // The native key event was handled by IMContextWrapper.
+  eHandled,
+  // The native key event has not been handled by IMContextWrapper,
+  // but eKeyDown or eKeyUp event has been dispatched.
+  eNotHandledButEventDispatched,
+  // The native key event has not been handled by IMContextWrapper,
+  // but eKeyDown or eKeyUp event has been dispatched and consumed.
+  eNotHandledButEventConsumed,
+};
+
+class IMContextWrapper final : public TextEventDispatcherListener {
+ public:
+  // TextEventDispatcherListener implementation
+  NS_DECL_ISUPPORTS
+
+  NS_IMETHOD NotifyIME(TextEventDispatcher* aTextEventDispatcher,
+                       const IMENotification& aNotification) override;
+  NS_IMETHOD_(IMENotificationRequests) GetIMENotificationRequests() override;
+  NS_IMETHOD_(void)
+  OnRemovedFrom(TextEventDispatcher* aTextEventDispatcher) override;
+  NS_IMETHOD_(void)
+  WillDispatchKeyboardEvent(TextEventDispatcher* aTextEventDispatcher,
+                            WidgetKeyboardEvent& aKeyboardEvent,
+                            uint32_t aIndexOfKeypress, void* aData) override;
+
+ public:
+  // aOwnerWindow is a pointer of the owner window.  When aOwnerWindow is
+  // destroyed, the related IME contexts are released (i.e., IME cannot be
+  // used with the instance after that).
+  explicit IMContextWrapper(nsWindow* aOwnerWindow);
+
+  // Called when the process is being shut down.
+  static void Shutdown();
+
+  // "Enabled" means the users can use all IMEs.
+  // I.e., the focus is in the normal editors.
+  bool IsEnabled() const;
+
+  // OnFocusWindow is a notification that aWindow is going to be focused.
+  void OnFocusWindow(nsWindow* aWindow);
+  // OnBlurWindow is a notification that aWindow is going to be unfocused.
+  void OnBlurWindow(nsWindow* aWindow);
+  // OnDestroyWindow is a notification that aWindow is going to be destroyed.
+  void OnDestroyWindow(nsWindow* aWindow);
+  // OnFocusChangeInGecko is a notification that an editor gets focus.
+  void OnFocusChangeInGecko(bool aFocus);
+  // OnSelectionChange is a notification that selection (caret) is changed
+  // in the focused editor.
+  void OnSelectionChange(nsWindow* aCaller,
+                         const IMENotification& aIMENotification);
+  // OnThemeChanged is called when desktop theme is changed.
+  static void OnThemeChanged();
+
+  /**
+   * OnKeyEvent() is called when aWindow gets a native key press event or a
+   * native key release event.  If this returns true, the key event was
+   * filtered by IME.  Otherwise, this returns false.
+   * NOTE: When the native key press event starts composition, this returns
+   *       true but dispatches an eKeyDown event or eKeyUp event before
+   *       dispatching composition events or content command event.
+   *
+   * @param aWindow                       A window on which user operate the
+   *                                      key.
+   * @param aEvent                        A native key press or release
+   *                                      event.
+   * @param aKeyboardEventWasDispatched   true if eKeyDown or eKeyUp event
+   *                                      for aEvent has already been
+   *                                      dispatched.  In this case,
+   *                                      this class doesn't dispatch
+   *                                      keyboard event anymore.
+   */
+  KeyHandlingState OnKeyEvent(nsWindow* aWindow, GdkEventKey* aEvent,
+                              bool aKeyboardEventWasDispatched = false);
+
+  // IME related nsIWidget methods.
+  nsresult EndIMEComposition(nsWindow* aCaller);
+  void SetInputContext(nsWindow* aCaller, const InputContext* aContext,
+                       const InputContextAction* aAction);
+  InputContext GetInputContext();
+  void OnUpdateComposition();
+  void OnLayoutChange();
+
+  TextEventDispatcher* GetTextEventDispatcher();
+
+  // TODO: Typically, new IM comes every several years.  And now, our code
+  //       becomes really IM behavior dependent.  So, perhaps, we need prefs
+  //       to control related flags for IM developers.
+  enum class IMContextID : uint8_t {
+    Fcitx,  // 4.x or earlier
+    Fcitx5,
+    IBus,
+    IIIMF,
+    Scim,
+    Uim,
+    Wayland,
+    Unknown,
+  };
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const IMContextID& aIMContextID) {
+    switch (aIMContextID) {
+      case IMContextID::Fcitx:
+        return aStream << "Fcitx";
+      case IMContextID::Fcitx5:
+        return aStream << "Fcitx5";
+      case IMContextID::IBus:
+        return aStream << "IBus";
+      case IMContextID::IIIMF:
+        return aStream << "IIIMF";
+      case IMContextID::Scim:
+        return aStream << "Scim";
+      case IMContextID::Uim:
+        return aStream << "Uim";
+      case IMContextID::Wayland:
+        return aStream << "Wayland";
+      case IMContextID::Unknown:
+        return aStream << "Unknown";
+    }
+    MOZ_ASSERT_UNREACHABLE("Add new case for the new IM support");
+    return aStream << "Unknown";
+  }
+
+  /**
+   * GetIMName() returns IM name associated with mContext.  If the context is
+   * xim, this look for actual engine from XMODIFIERS environment variable.
+   */
+  nsDependentCSubstring GetIMName() const;
+
+  /**
+   * GetWaitingSynthesizedKeyPressHardwareKeyCode() returns hardware_keycode
+   * value of last handled GDK_KEY_PRESS event which is probable handled by
+   * IME asynchronously and we have not received synthesized GDK_KEY_PRESS
+   * event yet.
+   */
+  static guint16 GetWaitingSynthesizedKeyPressHardwareKeyCode() {
+    return sWaitingSynthesizedKeyPressHardwareKeyCode;
+  }
+
+ protected:
+  ~IMContextWrapper();
+
+  /**
+   * SetInputPurposeAndInputHints() sets input-purpose and input-hints of
+   * current IM context to the values computed with mInputContext.
+   */
+  void SetInputPurposeAndInputHints();
+
+  // Owner of an instance of this class. This should be top level window.
+  // The owner window must release the contexts when it's destroyed because
+  // the IME contexts need the native window.  If OnDestroyWindow() is called
+  // with the owner window, it'll release IME contexts.  Otherwise, it'll
+  // just clean up any existing composition if it's related to the destroying
+  // child window.
+  nsWindow* mOwnerWindow;
+
+  // A last focused window in this class's context.
+  nsWindow* mLastFocusedWindow;
+
+  // Actual context. This is used for handling the user's input.
+  GtkIMContext* mContext;
+
+  // mSimpleContext is used for the password field and
+  // the |ime-mode: disabled;| editors if sUseSimpleContext is true.
+  // These editors disable IME.  But dead keys should work.  Fortunately,
+  // the simple IM context of GTK2 support only them.
+  GtkIMContext* mSimpleContext;
+
+  // mDummyContext is a dummy context and will be used in Focus()
+  // when the state of mEnabled means disabled.  This context's IME state is
+  // always "closed", so it closes IME forcedly.
+  GtkIMContext* mDummyContext;
+
+  // mComposingContext is not nullptr while one of mContext, mSimpleContext
+  // and mDummyContext has composition.
+  // XXX: We don't assume that two or more context have composition same time.
+  GtkIMContext* mComposingContext;
+
+  // IME enabled state and other things defined in InputContext.
+  // Use following helper methods if you don't need the detail of the status.
+  InputContext mInputContext;
+
+  // mCompositionStart is the start offset of the composition string in the
+  // current content.  When <textarea> or <input> have focus, it means offset
+  // from the first character of them.  When a HTML editor has focus, it
+  // means offset from the first character of the root element of the editor.
+  uint32_t mCompositionStart;
+
+  // mDispatchedCompositionString is the latest composition string which
+  // was dispatched by compositionupdate event.
+  nsString mDispatchedCompositionString;
+
+  // mSelectedStringRemovedByComposition is the selected string which was
+  // removed by first compositionchange event.
+  nsString mSelectedStringRemovedByComposition;
+
+  // OnKeyEvent() temporarily sets mProcessingKeyEvent to the given native
+  // event.
+  GdkEventKey* mProcessingKeyEvent;
+
+  /**
+   * GdkEventKeyQueue stores *copy* of GdkEventKey instances.  However, this
+   * must be safe to our usecase since it has |time| and the value should not
+   * be same as older event.
+   */
+  class GdkEventKeyQueue final {
+   public:
+    ~GdkEventKeyQueue() { Clear(); }
+
+    void Clear() { mEvents.Clear(); }
+
+    /**
+     * PutEvent() puts new event into the queue.
+     */
+    void PutEvent(const GdkEventKey* aEvent) {
+      GdkEventKey* newEvent = reinterpret_cast<GdkEventKey*>(
+          gdk_event_copy(reinterpret_cast<const GdkEvent*>(aEvent)));
+      newEvent->state &= GDK_MODIFIER_MASK;
+      mEvents.AppendElement(newEvent);
+    }
+
+    /**
+     * RemoveEvent() removes oldest same event and its preceding events
+     * from the queue.
+     */
+    void RemoveEvent(const GdkEventKey* aEvent) {
+      size_t index = IndexOf(aEvent);
+      if (NS_WARN_IF(index == GdkEventKeyQueue::NoIndex())) {
+        return;
+      }
+      mEvents.RemoveElementAt(index);
+    }
+
+    /**
+     * FirstEvent() returns oldest event in the queue.
+     */
+    GdkEventKey* GetFirstEvent() const {
+      if (mEvents.IsEmpty()) {
+        return nullptr;
+      }
+      return mEvents[0].get();
+    }
+
+    bool IsEmpty() const { return mEvents.IsEmpty(); }
+
+    static size_t NoIndex() { return nsTArray<GdkEventKey*>::NoIndex; }
+    size_t Length() const { return mEvents.Length(); }
+    size_t IndexOf(const GdkEventKey* aEvent) const {
+      static_assert(!(GDK_MODIFIER_MASK & (1 << 24)),
+                    "We assumes 25th bit is used by some IM, but used by GDK");
+      static_assert(!(GDK_MODIFIER_MASK & (1 << 25)),
+                    "We assumes 26th bit is used by some IM, but used by GDK");
+      for (size_t i = 0; i < mEvents.Length(); i++) {
+        GdkEventKey* event = mEvents[i].get();
+        // It must be enough to compare only type, time, keyval and
+        // part of state.   Note that we cannot compaire two events
+        // simply since IME may have changed unused bits of state.
+        if (event->time == aEvent->time) {
+          if (NS_WARN_IF(event->type != aEvent->type) ||
+              NS_WARN_IF(event->keyval != aEvent->keyval) ||
+              NS_WARN_IF(event->state != (aEvent->state & GDK_MODIFIER_MASK))) {
+            continue;
+          }
+        }
+        return i;
+      }
+      return GdkEventKeyQueue::NoIndex();
+    }
+
+   private:
+    nsTArray<GUniquePtr<GdkEventKey>> mEvents;
+  };
+  // OnKeyEvent() append mPostingKeyEvents when it believes that a key event
+  // is posted to other IME process.
+  GdkEventKeyQueue mPostingKeyEvents;
+
+  static guint16 sWaitingSynthesizedKeyPressHardwareKeyCode;
+
+  struct Range {
+    uint32_t mOffset;
+    uint32_t mLength;
+
+    Range() : mOffset(UINT32_MAX), mLength(UINT32_MAX) {}
+
+    bool IsValid() const { return mOffset != UINT32_MAX; }
+    void Clear() {
+      mOffset = UINT32_MAX;
+      mLength = UINT32_MAX;
+    }
+  };
+
+  // current target offset and length of IME composition
+  Range mCompositionTargetRange;
+
+  // mCompositionState indicates current status of composition.
+  enum eCompositionState : uint8_t {
+    eCompositionState_NotComposing,
+    eCompositionState_CompositionStartDispatched,
+    eCompositionState_CompositionChangeEventDispatched
+  };
+  eCompositionState mCompositionState;
+
+  bool IsComposing() const {
+    return (mCompositionState != eCompositionState_NotComposing);
+  }
+
+  bool IsComposingOn(GtkIMContext* aContext) const {
+    return IsComposing() && mComposingContext == aContext;
+  }
+
+  bool IsComposingOnCurrentContext() const {
+    return IsComposingOn(GetCurrentContext());
+  }
+
+  bool EditorHasCompositionString() {
+    return (mCompositionState ==
+            eCompositionState_CompositionChangeEventDispatched);
+  }
+
+  /**
+   * Checks if aContext is valid context for handling composition.
+   *
+   * @param aContext          An IM context which is specified by native
+   *                          composition events.
+   * @return                  true if the context is valid context for
+   *                          handling composition.  Otherwise, false.
+   */
+  bool IsValidContext(GtkIMContext* aContext) const;
+
+  const char* GetCompositionStateName() {
+    switch (mCompositionState) {
+      case eCompositionState_NotComposing:
+        return "NotComposing";
+      case eCompositionState_CompositionStartDispatched:
+        return "CompositionStartDispatched";
+      case eCompositionState_CompositionChangeEventDispatched:
+        return "CompositionChangeEventDispatched";
+      default:
+        return "InvaildState";
+    }
+  }
+
+  // mIMContextID indicates the ID of mContext.  This is actually indicates
+  // IM which user selected.
+  IMContextID mIMContextID;
+
+  // If mContentSelection is Nothing, it means that
+  // EnsureToCacheContentSelection failed to get selection or just not caching
+  // the selection.
+  Maybe<ContentSelection> mContentSelection;
+
+  /**
+   * Return true if mContentSelection is set to some.  Otherwise, false.
+   */
+  bool EnsureToCacheContentSelection(nsAString* aSelectedString = nullptr);
+
+  enum class IMEFocusState : uint8_t {
+    // IME has focus
+    Focused,
+    // IME was blurred
+    Blurred,
+    // IME was blurred without a focus change
+    BlurredWithoutFocusChange,
+  };
+  friend std::ostream& operator<<(std::ostream& aStream, IMEFocusState aState) {
+    switch (aState) {
+      case IMEFocusState::Focused:
+        return aStream << "IMEFocusState::Focused";
+      case IMEFocusState::Blurred:
+        return aStream << "IMEFocusState::Blurred";
+      case IMEFocusState::BlurredWithoutFocusChange:
+        return aStream << "IMEFocusState::BlurredWithoutFocusChange";
+      default:
+        MOZ_ASSERT_UNREACHABLE("Invalid value");
+        return aStream << "<illegal value>";
+    }
+  }
+  IMEFocusState mIMEFocusState = IMEFocusState::Blurred;
+
+  // mFallbackToKeyEvent is set to false when this class starts to handle
+  // a native key event (at that time, mProcessingKeyEvent is set to the
+  // native event).  If active IME just commits composition with a character
+  // which is produced by the key with current keyboard layout, this is set
+  // to true.
+  bool mFallbackToKeyEvent;
+  // mKeyboardEventWasDispatched is used by OnKeyEvent() and
+  // MaybeDispatchKeyEventAsProcessedByIME().
+  // MaybeDispatchKeyEventAsProcessedByIME() dispatches an eKeyDown or
+  // eKeyUp event event if the composition is caused by a native
+  // key press event.  If this is true, a keyboard event has been dispatched
+  // for the native event.  If so, MaybeDispatchKeyEventAsProcessedByIME()
+  // won't dispatch keyboard event anymore.
+  bool mKeyboardEventWasDispatched;
+  // Whether the keyboard event which as dispatched at setting
+  // mKeyboardEventWasDispatched to true was consumed or not.
+  bool mKeyboardEventWasConsumed;
+  // mIsDeletingSurrounding is true while OnDeleteSurroundingNative() is
+  // trying to delete the surrounding text.
+  bool mIsDeletingSurrounding;
+  // mLayoutChanged is true after OnLayoutChange() is called.  This is reset
+  // when eCompositionChange is being dispatched.
+  bool mLayoutChanged;
+  // mSetCursorPositionOnKeyEvent true when caret rect or position is updated
+  // with no composition.  If true, we update candidate window position
+  // before key down
+  bool mSetCursorPositionOnKeyEvent;
+  // mPendingResettingIMContext becomes true if selection change notification
+  // is received during composition but the selection change occurred before
+  // starting the composition.  In such case, we cannot notify IME of
+  // selection change during composition because we don't want to commit
+  // the composition in such case.  However, we should notify IME of the
+  // selection change after the composition is committed.
+  bool mPendingResettingIMContext;
+  // mRetrieveSurroundingSignalReceived is true after "retrieve_surrounding"
+  // signal is received until selection is changed in Gecko.
+  bool mRetrieveSurroundingSignalReceived;
+  // mMaybeInDeadKeySequence is set to true when we detect a dead key press
+  // and set to false when we're sure dead key sequence has been finished.
+  // Note that we cannot detect which key event causes ending a dead key
+  // sequence.  For example, when you press dead key grave with ibus Spanish
+  // keyboard layout, it just consumes the key event when we call
+  // gtk_im_context_filter_keypress().  Then, pressing "Escape" key cancels
+  // the dead key sequence but we don't receive any signal and it's consumed
+  // by gtk_im_context_filter_keypress() normally.  On the other hand, when
+  // pressing "Shift" key causes exactly same behavior but dead key sequence
+  // isn't finished yet.
+  bool mMaybeInDeadKeySequence;
+  // mIsIMInAsyncKeyHandlingMode is set to true if we know that IM handles
+  // key events asynchronously.  I.e., filtered key event may come again
+  // later.
+  bool mIsIMInAsyncKeyHandlingMode;
+  // mIsKeySnooped is set to true if IM uses key snooper to listen key events.
+  // In such case, we won't receive key events if IME consumes the event.
+  bool mIsKeySnooped;
+  // mSetInputPurposeAndInputHints is set if `SetInputContext` wants `Focus`
+  // to set input-purpose and input-hints.
+  bool mSetInputPurposeAndInputHints;
+
+  // sLastFocusedContext is a pointer to the last focused instance of this
+  // class.  When a instance is destroyed and sLastFocusedContext refers it,
+  // this is cleared.  So, this refers valid pointer always.
+  static IMContextWrapper* sLastFocusedContext;
+
+  // sUseSimpleContext indeicates if password editors and editors with
+  // |ime-mode: disabled;| should use GtkIMContextSimple.
+  // If true, they use GtkIMContextSimple.  Otherwise, not.
+  static bool sUseSimpleContext;
+
+  // Callback methods for native IME events.  These methods should call
+  // the related instance methods simply.
+  static gboolean OnRetrieveSurroundingCallback(GtkIMContext* aContext,
+                                                IMContextWrapper* aModule);
+  static gboolean OnDeleteSurroundingCallback(GtkIMContext* aContext,
+                                              gint aOffset, gint aNChars,
+                                              IMContextWrapper* aModule);
+  static void OnCommitCompositionCallback(GtkIMContext* aContext,
+                                          const gchar* aString,
+                                          IMContextWrapper* aModule);
+  static void OnChangeCompositionCallback(GtkIMContext* aContext,
+                                          IMContextWrapper* aModule);
+  static void OnStartCompositionCallback(GtkIMContext* aContext,
+                                         IMContextWrapper* aModule);
+  static void OnEndCompositionCallback(GtkIMContext* aContext,
+                                       IMContextWrapper* aModule);
+
+  // The instance methods for the native IME events.
+  gboolean OnRetrieveSurroundingNative(GtkIMContext* aContext);
+  gboolean OnDeleteSurroundingNative(GtkIMContext* aContext, gint aOffset,
+                                     gint aNChars);
+  void OnCommitCompositionNative(GtkIMContext* aContext, const gchar* aString);
+  void OnChangeCompositionNative(GtkIMContext* aContext);
+  void OnStartCompositionNative(GtkIMContext* aContext);
+  void OnEndCompositionNative(GtkIMContext* aContext);
+
+  /**
+   * GetCurrentContext() returns current IM context which is chosen with the
+   * enabled state.
+   * WARNING:
+   *     When this class receives some signals for a composition after focus
+   *     is moved in Gecko, the result of this may be different from given
+   *     context by the signals.
+   */
+  GtkIMContext* GetCurrentContext() const;
+
+  /**
+   * GetActiveContext() returns a composing context or current context.
+   */
+  GtkIMContext* GetActiveContext() const {
+    return mComposingContext ? mComposingContext : GetCurrentContext();
+  }
+
+  // If the owner window and IM context have been destroyed, returns TRUE.
+  bool IsDestroyed() { return !mOwnerWindow; }
+
+  void NotifyIMEOfFocusChange(IMEFocusState aIMEFocusState);
+
+  // Initializes the instance.
+  void Init();
+
+  /**
+   * Reset the active context, i.e., if there is mComposingContext, reset it.
+   * Otherwise, reset current context.  Note that all native composition
+   * events during calling this will be ignored.
+   */
+  void ResetIME();
+
+  // Gets the current composition string by the native APIs.
+  void GetCompositionString(GtkIMContext* aContext,
+                            nsAString& aCompositionString);
+
+  /**
+   * Generates our text range array from current composition string.
+   *
+   * @param aContext              A GtkIMContext which is being handled.
+   * @param aCompositionString    The data to be dispatched with
+   *                              compositionchange event.
+   */
+  already_AddRefed<TextRangeArray> CreateTextRangeArray(
+      GtkIMContext* aContext, const nsAString& aCompositionString);
+
+  /**
+   * SetTextRange() initializes aTextRange with aPangoAttrIter.
+   *
+   * @param aPangoAttrIter            An iter which represents a clause of the
+   *                                  composition string.
+   * @param aUTF8CompositionString    The whole composition string (UTF-8).
+   * @param aUTF16CaretOffset         The caret offset in the composition
+   *                                  string encoded as UTF-16.
+   * @param aTextRange                The result.
+   * @return                          true if this initializes aTextRange.
+   *                                  Otherwise, false.
+   */
+  bool SetTextRange(PangoAttrIterator* aPangoAttrIter,
+                    const gchar* aUTF8CompositionString,
+                    uint32_t aUTF16CaretOffset, TextRange& aTextRange) const;
+
+  /**
+   * ToNscolor() converts the PangoColor in aPangoAttrColor to nscolor.
+   */
+  static nscolor ToNscolor(PangoAttrColor* aPangoAttrColor);
+
+  /**
+   * Move the candidate window with "fake" cursor position.
+   *
+   * @param aContext              A GtkIMContext which is being handled.
+   */
+  void SetCursorPosition(GtkIMContext* aContext);
+
+  // Queries the current selection offset of the window.
+  uint32_t GetSelectionOffset(nsWindow* aWindow);
+
+  // Get current paragraph text content and cursor position
+  nsresult GetCurrentParagraph(nsAString& aText, uint32_t& aCursorPos);
+
+  /**
+   * Delete text portion
+   *
+   * @param aContext              A GtkIMContext which is being handled.
+   * @param aOffset               Start offset of the range to delete.
+   * @param aNChars               Count of characters to delete.  It depends
+   *                              on |g_utf8_strlen()| what is one character.
+   */
+  nsresult DeleteText(GtkIMContext* aContext, int32_t aOffset,
+                      uint32_t aNChars);
+
+  // Called before destroying the context to work around some platform bugs.
+  void PrepareToDestroyContext(GtkIMContext* aContext);
+
+  /**
+   *  WARNING:
+   *    Following methods dispatch gecko events.  Then, the focused widget
+   *    can be destroyed, and also it can be stolen focus.  If they returns
+   *    FALSE, callers cannot continue the composition.
+   *      - MaybeDispatchKeyEventAsProcessedByIME
+   *      - DispatchCompositionStart
+   *      - DispatchCompositionChangeEvent
+   *      - DispatchCompositionCommitEvent
+   */
+
+  /**
+   * Dispatch an eKeyDown or eKeyUp event whose mKeyCode value is
+   * NS_VK_PROCESSKEY and mKeyNameIndex is KEY_NAME_INDEX_Process if
+   * we're not in a dead key sequence, mProcessingKeyEvent is nullptr
+   * but mPostingKeyEvents is not empty or mProcessingKeyEvent is not
+   * nullptr and mKeyboardEventWasDispatched is still false.  If this
+   * dispatches a keyboard event, this sets mKeyboardEventWasDispatched
+   * to true.
+   *
+   * @param aFollowingEvent       The following event message.
+   * @return                      If the caller can continue to handle
+   *                              composition, returns true.  Otherwise,
+   *                              false.  For example, if focus is moved
+   *                              by dispatched keyboard event, returns
+   *                              false.
+   */
+  bool MaybeDispatchKeyEventAsProcessedByIME(EventMessage aFollowingEvent);
+
+  /**
+   * Dispatches a composition start event.
+   *
+   * @param aContext              A GtkIMContext which is being handled.
+   * @return                      true if the focused widget is neither
+   *                              destroyed nor changed.  Otherwise, false.
+   */
+  bool DispatchCompositionStart(GtkIMContext* aContext);
+
+  /**
+   * Dispatches a compositionchange event.
+   *
+   * @param aContext              A GtkIMContext which is being handled.
+   * @param aCompositionString    New composition string.
+   * @return                      true if the focused widget is neither
+   *                              destroyed nor changed.  Otherwise, false.
+   */
+  bool DispatchCompositionChangeEvent(GtkIMContext* aContext,
+                                      const nsAString& aCompositionString);
+
+  /**
+   * Dispatches a compositioncommit event or compositioncommitasis event.
+   *
+   * @param aContext              A GtkIMContext which is being handled.
+   * @param aCommitString         If this is nullptr, the composition will
+   *                              be committed with last dispatched data.
+   *                              Otherwise, the composition will be
+   *                              committed with this value.
+   * @return                      true if the focused widget is neither
+   *                              destroyed nor changed.  Otherwise, false.
+   */
+  bool DispatchCompositionCommitEvent(GtkIMContext* aContext,
+                                      const nsAString* aCommitString = nullptr);
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // #ifndef IMContextWrapper_h_
diff --git a/widget/gtk/InProcessGtkCompositorWidget.cpp b/widget/gtk/InProcessGtkCompositorWidget.cpp
new file mode 100644
index 0000000000..bffd6f5a7f
--- /dev/null
+++ b/widget/gtk/InProcessGtkCompositorWidget.cpp
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "HeadlessCompositorWidget.h"
+#include "HeadlessWidget.h"
+#include "mozilla/widget/PlatformWidgetTypes.h"
+
+#include "InProcessGtkCompositorWidget.h"
+#include "VsyncDispatcher.h"
+#include "nsWindow.h"
+
+namespace mozilla::widget {
+
+/* static */
+RefPtr<CompositorWidget> CompositorWidget::CreateLocal(
+    const CompositorWidgetInitData& aInitData,
+    const layers::CompositorOptions& aOptions, nsIWidget* aWidget) {
+  if (aInitData.type() ==
+      CompositorWidgetInitData::THeadlessCompositorWidgetInitData) {
+    return new HeadlessCompositorWidget(
+        aInitData.get_HeadlessCompositorWidgetInitData(), aOptions,
+        static_cast<HeadlessWidget*>(aWidget));
+  } else {
+    return new InProcessGtkCompositorWidget(
+        aInitData.get_GtkCompositorWidgetInitData(), aOptions,
+        static_cast<nsWindow*>(aWidget));
+  }
+}
+
+InProcessGtkCompositorWidget::InProcessGtkCompositorWidget(
+    const GtkCompositorWidgetInitData& aInitData,
+    const layers::CompositorOptions& aOptions, nsWindow* aWindow)
+    : GtkCompositorWidget(aInitData, aOptions, aWindow) {}
+
+void InProcessGtkCompositorWidget::ObserveVsync(VsyncObserver* aObserver) {
+  if (RefPtr<CompositorVsyncDispatcher> cvd =
+          mWidget->GetCompositorVsyncDispatcher()) {
+    cvd->SetCompositorVsyncObserver(aObserver);
+  }
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/InProcessGtkCompositorWidget.h b/widget/gtk/InProcessGtkCompositorWidget.h
new file mode 100644
index 0000000000..bd7e68d6fb
--- /dev/null
+++ b/widget/gtk/InProcessGtkCompositorWidget.h
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef widget_gtk_InProcessGtkCompositorWidget_h
+#define widget_gtk_InProcessGtkCompositorWidget_h
+
+#include "GtkCompositorWidget.h"
+
+class nsWindow;
+
+namespace mozilla {
+namespace widget {
+
+class InProcessGtkCompositorWidget final : public GtkCompositorWidget {
+ public:
+  InProcessGtkCompositorWidget(const GtkCompositorWidgetInitData& aInitData,
+                               const layers::CompositorOptions& aOptions,
+                               nsWindow* aWindow);
+
+  // CompositorWidgetDelegate
+
+  void ObserveVsync(VsyncObserver* aObserver) override;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // widget_gtk_InProcessGtkCompositorWidget_h
diff --git a/widget/gtk/MPRISInterfaceDescription.h b/widget/gtk/MPRISInterfaceDescription.h
new file mode 100644
index 0000000000..28e719e651
--- /dev/null
+++ b/widget/gtk/MPRISInterfaceDescription.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WIDGET_GTK_MPRIS_INTERFACE_DESCRIPTION_H_
+#define WIDGET_GTK_MPRIS_INTERFACE_DESCRIPTION_H_
+
+#include <gio/gio.h>
+
+extern const gchar introspection_xml[] =
+    // adopted from https://github.com/freedesktop/mpris-spec/blob/master/spec/org.mpris.MediaPlayer2.xml
+    // everything starting with tp can be removed, as it is used for HTML Spec Documentation Generation
+    "<node>"
+        "<interface name=\"org.mpris.MediaPlayer2\">"
+            "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "<method name=\"Raise\"/>"
+            "<method name=\"Quit\"/>"
+            "<property name=\"CanQuit\" type=\"b\" access=\"read\"/>"
+            "<property name=\"CanRaise\" type=\"b\" access=\"read\"/>"
+            "<property name=\"HasTrackList\" type=\"b\" access=\"read\"/>"
+            "<property name=\"Identity\" type=\"s\" access=\"read\"/>"
+            "<property name=\"DesktopEntry\" type=\"s\" access=\"read\"/>"
+            "<property name=\"SupportedUriSchemes\" type=\"as\" access=\"read\"/>"
+            "<property name=\"SupportedMimeTypes\" type=\"as\" access=\"read\"/>"
+        "</interface>"
+            // Note that every property emits a changed signal (which is default) apart from Position.
+        "<interface name=\"org.mpris.MediaPlayer2.Player\">"
+            "<method name=\"Next\"/>"
+            "<method name=\"Previous\"/>"
+            "<method name=\"Pause\"/>"
+            "<method name=\"PlayPause\"/>"
+            "<method name=\"Stop\"/>"
+            "<method name=\"Play\"/>"
+            "<method name=\"Seek\">"
+                "<arg direction=\"in\" type=\"x\" name=\"Offset\"/>"
+            "</method>"
+            "<method name=\"SetPosition\">"
+                "<arg direction=\"in\" type=\"o\" name=\"TrackId\"/>"
+                "<arg direction=\"in\" type=\"x\" name=\"Position\"/>"
+            "</method>"
+            "<method name=\"OpenUri\">"
+                "<arg direction=\"in\" type=\"s\" name=\"Uri\"/>"
+            "</method>"
+            "<property name=\"PlaybackStatus\" type=\"s\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"Rate\" type=\"d\" access=\"readwrite\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"Metadata\" type=\"a{sv}\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"Volume\" type=\"d\" access=\"readwrite\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"Position\" type=\"x\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"false\"/>"
+            "</property>"
+            "<property name=\"MinimumRate\" type=\"d\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"MaximumRate\" type=\"d\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"CanGoNext\" type=\"b\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"CanGoPrevious\" type=\"b\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"CanPlay\" type=\"b\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"CanPause\" type=\"b\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"CanSeek\" type=\"b\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"true\"/>"
+            "</property>"
+            "<property name=\"CanControl\" type=\"b\" access=\"read\">"
+                "<annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"false\"/>"
+            "</property>"
+            "<signal name=\"Seeked\">"
+                "<arg name=\"Position\" type=\"x\"/>"
+            "</signal>"
+        "</interface>"
+    "</node>";
+
+#endif  // WIDGET_GTK_MPRIS_INTERFACE_DESCRIPTION_H_
diff --git a/widget/gtk/MPRISServiceHandler.cpp b/widget/gtk/MPRISServiceHandler.cpp
new file mode 100644
index 0000000000..4080b56c17
--- /dev/null
+++ b/widget/gtk/MPRISServiceHandler.cpp
@@ -0,0 +1,856 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MPRISServiceHandler.h"
+
+#include <stdint.h>
+#include <inttypes.h>
+#include <unordered_map>
+
+#include "MPRISInterfaceDescription.h"
+#include "mozilla/dom/MediaControlUtils.h"
+#include "mozilla/GRefPtr.h"
+#include "mozilla/GUniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Sprintf.h"
+#include "nsXULAppAPI.h"
+#include "nsIXULAppInfo.h"
+#include "nsIOutputStream.h"
+#include "nsNetUtil.h"
+#include "nsServiceManagerUtils.h"
+#include "WidgetUtilsGtk.h"
+#include "prio.h"
+
+#define LOGMPRIS(msg, ...)                   \
+  MOZ_LOG(gMediaControlLog, LogLevel::Debug, \
+          ("MPRISServiceHandler=%p, " msg, this, ##__VA_ARGS__))
+
+namespace mozilla {
+namespace widget {
+
+// A global counter tracking the total images saved in the system and it will be
+// used to form a unique image file name.
+static uint32_t gImageNumber = 0;
+
+static inline Maybe<dom::MediaControlKey> GetMediaControlKey(
+    const gchar* aMethodName) {
+  const std::unordered_map<std::string, dom::MediaControlKey> map = {
+      {"Raise", dom::MediaControlKey::Focus},
+      {"Next", dom::MediaControlKey::Nexttrack},
+      {"Previous", dom::MediaControlKey::Previoustrack},
+      {"Pause", dom::MediaControlKey::Pause},
+      {"PlayPause", dom::MediaControlKey::Playpause},
+      {"Stop", dom::MediaControlKey::Stop},
+      {"Play", dom::MediaControlKey::Play}};
+
+  auto it = map.find(aMethodName);
+  return it == map.end() ? Nothing() : Some(it->second);
+}
+
+static void HandleMethodCall(GDBusConnection* aConnection, const gchar* aSender,
+                             const gchar* aObjectPath,
+                             const gchar* aInterfaceName,
+                             const gchar* aMethodName, GVariant* aParameters,
+                             GDBusMethodInvocation* aInvocation,
+                             gpointer aUserData) {
+  MOZ_ASSERT(aUserData);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  Maybe<dom::MediaControlKey> key = GetMediaControlKey(aMethodName);
+  if (key.isNothing()) {
+    g_dbus_method_invocation_return_error(
+        aInvocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED,
+        "Method %s.%s.%s not supported", aObjectPath, aInterfaceName,
+        aMethodName);
+    return;
+  }
+
+  MPRISServiceHandler* handler = static_cast<MPRISServiceHandler*>(aUserData);
+  if (handler->PressKey(key.value())) {
+    g_dbus_method_invocation_return_value(aInvocation, nullptr);
+  } else {
+    g_dbus_method_invocation_return_error(
+        aInvocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
+        "%s.%s.%s is not available now", aObjectPath, aInterfaceName,
+        aMethodName);
+  }
+}
+
+enum class Property : uint8_t {
+  eIdentity,
+  eDesktopEntry,
+  eHasTrackList,
+  eCanRaise,
+  eCanQuit,
+  eSupportedUriSchemes,
+  eSupportedMimeTypes,
+  eCanGoNext,
+  eCanGoPrevious,
+  eCanPlay,
+  eCanPause,
+  eCanSeek,
+  eCanControl,
+  eGetPlaybackStatus,
+  eGetMetadata,
+};
+
+static inline Maybe<dom::MediaControlKey> GetPairedKey(Property aProperty) {
+  switch (aProperty) {
+    case Property::eCanRaise:
+      return Some(dom::MediaControlKey::Focus);
+    case Property::eCanGoNext:
+      return Some(dom::MediaControlKey::Nexttrack);
+    case Property::eCanGoPrevious:
+      return Some(dom::MediaControlKey::Previoustrack);
+    case Property::eCanPlay:
+      return Some(dom::MediaControlKey::Play);
+    case Property::eCanPause:
+      return Some(dom::MediaControlKey::Pause);
+    default:
+      return Nothing();
+  }
+}
+
+static inline Maybe<Property> GetProperty(const gchar* aPropertyName) {
+  const std::unordered_map<std::string, Property> map = {
+      // org.mpris.MediaPlayer2 properties
+      {"Identity", Property::eIdentity},
+      {"DesktopEntry", Property::eDesktopEntry},
+      {"HasTrackList", Property::eHasTrackList},
+      {"CanRaise", Property::eCanRaise},
+      {"CanQuit", Property::eCanQuit},
+      {"SupportedUriSchemes", Property::eSupportedUriSchemes},
+      {"SupportedMimeTypes", Property::eSupportedMimeTypes},
+      // org.mpris.MediaPlayer2.Player properties
+      {"CanGoNext", Property::eCanGoNext},
+      {"CanGoPrevious", Property::eCanGoPrevious},
+      {"CanPlay", Property::eCanPlay},
+      {"CanPause", Property::eCanPause},
+      {"CanSeek", Property::eCanSeek},
+      {"CanControl", Property::eCanControl},
+      {"PlaybackStatus", Property::eGetPlaybackStatus},
+      {"Metadata", Property::eGetMetadata}};
+
+  auto it = map.find(aPropertyName);
+  return (it == map.end() ? Nothing() : Some(it->second));
+}
+
+static GVariant* HandleGetProperty(GDBusConnection* aConnection,
+                                   const gchar* aSender,
+                                   const gchar* aObjectPath,
+                                   const gchar* aInterfaceName,
+                                   const gchar* aPropertyName, GError** aError,
+                                   gpointer aUserData) {
+  MOZ_ASSERT(aUserData);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  Maybe<Property> property = GetProperty(aPropertyName);
+  if (property.isNothing()) {
+    g_set_error(aError, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED,
+                "%s.%s %s is not supported", aObjectPath, aInterfaceName,
+                aPropertyName);
+    return nullptr;
+  }
+
+  MPRISServiceHandler* handler = static_cast<MPRISServiceHandler*>(aUserData);
+  switch (property.value()) {
+    case Property::eSupportedUriSchemes:
+    case Property::eSupportedMimeTypes:
+      // No plan to implement OpenUri for now
+      return g_variant_new_strv(nullptr, 0);
+    case Property::eGetPlaybackStatus:
+      return handler->GetPlaybackStatus();
+    case Property::eGetMetadata:
+      return handler->GetMetadataAsGVariant();
+    case Property::eIdentity:
+      return g_variant_new_string(handler->Identity());
+    case Property::eDesktopEntry:
+      return g_variant_new_string(handler->DesktopEntry());
+    case Property::eHasTrackList:
+    case Property::eCanQuit:
+    case Property::eCanSeek:
+      return g_variant_new_boolean(false);
+    // Play/Pause would be blocked if CanControl is false
+    case Property::eCanControl:
+      return g_variant_new_boolean(true);
+    case Property::eCanRaise:
+    case Property::eCanGoNext:
+    case Property::eCanGoPrevious:
+    case Property::eCanPlay:
+    case Property::eCanPause:
+      Maybe<dom::MediaControlKey> key = GetPairedKey(property.value());
+      MOZ_ASSERT(key.isSome());
+      return g_variant_new_boolean(handler->IsMediaKeySupported(key.value()));
+  }
+
+  MOZ_ASSERT_UNREACHABLE("Switch statement is incomplete");
+  return nullptr;
+}
+
+static gboolean HandleSetProperty(GDBusConnection* aConnection,
+                                  const gchar* aSender,
+                                  const gchar* aObjectPath,
+                                  const gchar* aInterfaceName,
+                                  const gchar* aPropertyName, GVariant* aValue,
+                                  GError** aError, gpointer aUserData) {
+  MOZ_ASSERT(aUserData);
+  MOZ_ASSERT(NS_IsMainThread());
+  g_set_error(aError, G_IO_ERROR, G_IO_ERROR_FAILED,
+              "%s:%s setting is not supported", aInterfaceName, aPropertyName);
+  return false;
+}
+
+static const GDBusInterfaceVTable gInterfaceVTable = {
+    HandleMethodCall, HandleGetProperty, HandleSetProperty};
+
+void MPRISServiceHandler::OnNameAcquiredStatic(GDBusConnection* aConnection,
+                                               const gchar* aName,
+                                               gpointer aUserData) {
+  MOZ_ASSERT(aUserData);
+  static_cast<MPRISServiceHandler*>(aUserData)->OnNameAcquired(aConnection,
+                                                               aName);
+}
+
+void MPRISServiceHandler::OnNameLostStatic(GDBusConnection* aConnection,
+                                           const gchar* aName,
+                                           gpointer aUserData) {
+  MOZ_ASSERT(aUserData);
+  static_cast<MPRISServiceHandler*>(aUserData)->OnNameLost(aConnection, aName);
+}
+
+void MPRISServiceHandler::OnBusAcquiredStatic(GDBusConnection* aConnection,
+                                              const gchar* aName,
+                                              gpointer aUserData) {
+  MOZ_ASSERT(aUserData);
+  static_cast<MPRISServiceHandler*>(aUserData)->OnBusAcquired(aConnection,
+                                                              aName);
+}
+
+void MPRISServiceHandler::OnNameAcquired(GDBusConnection* aConnection,
+                                         const gchar* aName) {
+  LOGMPRIS("OnNameAcquired: %s", aName);
+  mConnection = aConnection;
+}
+
+void MPRISServiceHandler::OnNameLost(GDBusConnection* aConnection,
+                                     const gchar* aName) {
+  LOGMPRIS("OnNameLost: %s", aName);
+  mConnection = nullptr;
+  if (!mRootRegistrationId) {
+    return;
+  }
+
+  if (g_dbus_connection_unregister_object(aConnection, mRootRegistrationId)) {
+    mRootRegistrationId = 0;
+  } else {
+    // Note: Most code examples in the internet probably dont't even check the
+    // result here, but
+    // according to the spec it _can_ return false.
+    LOGMPRIS("Unable to unregister root object from within onNameLost!");
+  }
+
+  if (!mPlayerRegistrationId) {
+    return;
+  }
+
+  if (g_dbus_connection_unregister_object(aConnection, mPlayerRegistrationId)) {
+    mPlayerRegistrationId = 0;
+  } else {
+    // Note: Most code examples in the internet probably dont't even check the
+    // result here, but
+    // according to the spec it _can_ return false.
+    LOGMPRIS("Unable to unregister object from within onNameLost!");
+  }
+}
+
+void MPRISServiceHandler::OnBusAcquired(GDBusConnection* aConnection,
+                                        const gchar* aName) {
+  GUniquePtr<GError> error;
+  LOGMPRIS("OnBusAcquired: %s", aName);
+
+  mRootRegistrationId = g_dbus_connection_register_object(
+      aConnection, DBUS_MPRIS_OBJECT_PATH, mIntrospectionData->interfaces[0],
+      &gInterfaceVTable, this,  /* user_data */
+      nullptr,                  /* user_data_free_func */
+      getter_Transfers(error)); /* GError** */
+
+  if (mRootRegistrationId == 0) {
+    LOGMPRIS("Failed at root registration: %s",
+             error ? error->message : "Unknown Error");
+    return;
+  }
+
+  mPlayerRegistrationId = g_dbus_connection_register_object(
+      aConnection, DBUS_MPRIS_OBJECT_PATH, mIntrospectionData->interfaces[1],
+      &gInterfaceVTable, this,  /* user_data */
+      nullptr,                  /* user_data_free_func */
+      getter_Transfers(error)); /* GError** */
+
+  if (mPlayerRegistrationId == 0) {
+    LOGMPRIS("Failed at object registration: %s",
+             error ? error->message : "Unknown Error");
+  }
+}
+
+bool MPRISServiceHandler::Open() {
+  MOZ_ASSERT(!mInitialized);
+  MOZ_ASSERT(NS_IsMainThread());
+  GUniquePtr<GError> error;
+  gchar serviceName[256];
+
+  InitIdentity();
+  SprintfLiteral(serviceName, DBUS_MPRIS_SERVICE_NAME ".instance%d", getpid());
+  mOwnerId =
+      g_bus_own_name(G_BUS_TYPE_SESSION, serviceName,
+                     // Enter a waiting queue until this service name is free
+                     // (likely another FF instance is running/has been crashed)
+                     G_BUS_NAME_OWNER_FLAGS_NONE, OnBusAcquiredStatic,
+                     OnNameAcquiredStatic, OnNameLostStatic, this, nullptr);
+
+  /* parse introspection data */
+  mIntrospectionData = dont_AddRef(
+      g_dbus_node_info_new_for_xml(introspection_xml, getter_Transfers(error)));
+
+  if (!mIntrospectionData) {
+    LOGMPRIS("Failed at parsing XML Interface definition: %s",
+             error ? error->message : "Unknown Error");
+    return false;
+  }
+
+  mInitialized = true;
+  return true;
+}
+
+MPRISServiceHandler::MPRISServiceHandler() = default;
+MPRISServiceHandler::~MPRISServiceHandler() {
+  MOZ_ASSERT(!mInitialized, "Close hasn't been called!");
+}
+
+void MPRISServiceHandler::Close() {
+  gchar serviceName[256];
+  SprintfLiteral(serviceName, DBUS_MPRIS_SERVICE_NAME ".instance%d", getpid());
+
+  // Reset playback state and metadata before disconnect from dbus.
+  SetPlaybackState(dom::MediaSessionPlaybackState::None);
+  ClearMetadata();
+
+  OnNameLost(mConnection, serviceName);
+
+  if (mOwnerId != 0) {
+    g_bus_unown_name(mOwnerId);
+  }
+
+  mIntrospectionData = nullptr;
+
+  mInitialized = false;
+  MediaControlKeySource::Close();
+}
+
+bool MPRISServiceHandler::IsOpened() const { return mInitialized; }
+
+void MPRISServiceHandler::InitIdentity() {
+  nsresult rv;
+  nsCOMPtr<nsIXULAppInfo> appInfo =
+      do_GetService("@mozilla.org/xre/app-info;1", &rv);
+
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  rv = appInfo->GetVendor(mIdentity);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  rv = appInfo->GetName(mDesktopEntry);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+  mIdentity.Append(' ');
+  mIdentity.Append(mDesktopEntry);
+
+  // Compute the desktop entry name like nsAppRunner does for g_set_prgname
+  ToLowerCase(mDesktopEntry);
+}
+
+const char* MPRISServiceHandler::Identity() const {
+  NS_WARNING_ASSERTION(mInitialized,
+                       "MPRISServiceHandler should have been initialized.");
+  return mIdentity.get();
+}
+
+const char* MPRISServiceHandler::DesktopEntry() const {
+  NS_WARNING_ASSERTION(mInitialized,
+                       "MPRISServiceHandler should have been initialized.");
+  return mDesktopEntry.get();
+}
+
+bool MPRISServiceHandler::PressKey(dom::MediaControlKey aKey) const {
+  MOZ_ASSERT(mInitialized);
+  if (!IsMediaKeySupported(aKey)) {
+    LOGMPRIS("%s is not supported", ToMediaControlKeyStr(aKey));
+    return false;
+  }
+  LOGMPRIS("Press %s", ToMediaControlKeyStr(aKey));
+  EmitEvent(aKey);
+  return true;
+}
+
+void MPRISServiceHandler::SetPlaybackState(
+    dom::MediaSessionPlaybackState aState) {
+  LOGMPRIS("SetPlaybackState");
+  if (mPlaybackState == aState) {
+    return;
+  }
+
+  MediaControlKeySource::SetPlaybackState(aState);
+
+  GVariant* state = GetPlaybackStatus();
+  GVariantBuilder builder;
+  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
+  g_variant_builder_add(&builder, "{sv}", "PlaybackStatus", state);
+
+  GVariant* parameters = g_variant_new(
+      "(sa{sv}as)", DBUS_MPRIS_PLAYER_INTERFACE, &builder, nullptr);
+
+  LOGMPRIS("Emitting MPRIS property changes for 'PlaybackStatus'");
+  Unused << EmitPropertiesChangedSignal(parameters);
+}
+
+GVariant* MPRISServiceHandler::GetPlaybackStatus() const {
+  switch (GetPlaybackState()) {
+    case dom::MediaSessionPlaybackState::Playing:
+      return g_variant_new_string("Playing");
+    case dom::MediaSessionPlaybackState::Paused:
+      return g_variant_new_string("Paused");
+    case dom::MediaSessionPlaybackState::None:
+      return g_variant_new_string("Stopped");
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid Playback State");
+      return nullptr;
+  }
+}
+
+void MPRISServiceHandler::SetMediaMetadata(
+    const dom::MediaMetadataBase& aMetadata) {
+  // Reset the index of the next available image to be fetched in the artwork,
+  // before checking the fetching process should be started or not. The image
+  // fetching process could be skipped if the image being fetching currently is
+  // in the artwork. If the current image fetching fails, the next availabe
+  // candidate should be the first image in the latest artwork
+  mNextImageIndex = 0;
+
+  // No need to fetch a MPRIS image if
+  // 1) MPRIS image is being fetched, and the one in fetching is in the artwork
+  // 2) MPRIS image is not being fetched, and the one in use is in the artwork
+  if (!mFetchingUrl.IsEmpty()) {
+    if (dom::IsImageIn(aMetadata.mArtwork, mFetchingUrl)) {
+      LOGMPRIS(
+          "No need to load MPRIS image. The one being processed is in the "
+          "artwork");
+      // Set MPRIS without the image first. The image will be loaded to MPRIS
+      // asynchronously once it's fetched and saved into a local file
+      SetMediaMetadataInternal(aMetadata);
+      return;
+    }
+  } else if (!mCurrentImageUrl.IsEmpty()) {
+    if (dom::IsImageIn(aMetadata.mArtwork, mCurrentImageUrl)) {
+      LOGMPRIS("No need to load MPRIS image. The one in use is in the artwork");
+      SetMediaMetadataInternal(aMetadata, false);
+      return;
+    }
+  }
+
+  // Set MPRIS without the image first then load the image to MPRIS
+  // asynchronously
+  SetMediaMetadataInternal(aMetadata);
+  LoadImageAtIndex(mNextImageIndex++);
+}
+
+bool MPRISServiceHandler::EmitMetadataChanged() const {
+  GVariantBuilder builder;
+  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
+  g_variant_builder_add(&builder, "{sv}", "Metadata", GetMetadataAsGVariant());
+
+  GVariant* parameters = g_variant_new(
+      "(sa{sv}as)", DBUS_MPRIS_PLAYER_INTERFACE, &builder, nullptr);
+
+  LOGMPRIS("Emit MPRIS property changes for 'Metadata'");
+  return EmitPropertiesChangedSignal(parameters);
+}
+
+void MPRISServiceHandler::SetMediaMetadataInternal(
+    const dom::MediaMetadataBase& aMetadata, bool aClearArtUrl) {
+  mMPRISMetadata.UpdateFromMetadataBase(aMetadata);
+  if (aClearArtUrl) {
+    mMPRISMetadata.mArtUrl.Truncate();
+  }
+  EmitMetadataChanged();
+}
+
+void MPRISServiceHandler::ClearMetadata() {
+  mMPRISMetadata.Clear();
+  mImageFetchRequest.DisconnectIfExists();
+  RemoveAllLocalImages();
+  mCurrentImageUrl.Truncate();
+  mFetchingUrl.Truncate();
+  mNextImageIndex = 0;
+  mSupportedKeys = 0;
+  EmitMetadataChanged();
+}
+
+void MPRISServiceHandler::LoadImageAtIndex(const size_t aIndex) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (aIndex >= mMPRISMetadata.mArtwork.Length()) {
+    LOGMPRIS("Stop loading image to MPRIS. No available image");
+    mImageFetchRequest.DisconnectIfExists();
+    return;
+  }
+
+  const dom::MediaImage& image = mMPRISMetadata.mArtwork[aIndex];
+
+  if (!dom::IsValidImageUrl(image.mSrc)) {
+    LOGMPRIS("Skip the image with invalid URL. Try next image");
+    LoadImageAtIndex(mNextImageIndex++);
+    return;
+  }
+
+  mImageFetchRequest.DisconnectIfExists();
+  mFetchingUrl = image.mSrc;
+
+  mImageFetcher = MakeUnique<dom::FetchImageHelper>(image);
+  RefPtr<MPRISServiceHandler> self = this;
+  mImageFetcher->FetchImage()
+      ->Then(
+          AbstractThread::MainThread(), __func__,
+          [this, self](const nsCOMPtr<imgIContainer>& aImage) {
+            LOGMPRIS("The image is fetched successfully");
+            mImageFetchRequest.Complete();
+
+            uint32_t size = 0;
+            char* data = nullptr;
+            // Only used to hold the image data
+            nsCOMPtr<nsIInputStream> inputStream;
+            nsresult rv = dom::GetEncodedImageBuffer(
+                aImage, mMimeType, getter_AddRefs(inputStream), &size, &data);
+            if (NS_FAILED(rv) || !inputStream || size == 0 || !data) {
+              LOGMPRIS("Failed to get the image buffer info. Try next image");
+              LoadImageAtIndex(mNextImageIndex++);
+              return;
+            }
+
+            if (SetImageToDisplay(data, size)) {
+              mCurrentImageUrl = mFetchingUrl;
+              LOGMPRIS("The MPRIS image is updated to the image from: %s",
+                       NS_ConvertUTF16toUTF8(mCurrentImageUrl).get());
+            } else {
+              LOGMPRIS("Failed to set image to MPRIS");
+              mCurrentImageUrl.Truncate();
+            }
+
+            mFetchingUrl.Truncate();
+          },
+          [this, self](bool) {
+            LOGMPRIS("Failed to fetch image. Try next image");
+            mImageFetchRequest.Complete();
+            mFetchingUrl.Truncate();
+            LoadImageAtIndex(mNextImageIndex++);
+          })
+      ->Track(mImageFetchRequest);
+}
+
+bool MPRISServiceHandler::SetImageToDisplay(const char* aImageData,
+                                            uint32_t aDataSize) {
+  if (!RenewLocalImageFile(aImageData, aDataSize)) {
+    return false;
+  }
+  MOZ_ASSERT(mLocalImageFile);
+
+  mMPRISMetadata.mArtUrl = nsCString("file://");
+  mMPRISMetadata.mArtUrl.Append(mLocalImageFile->NativePath());
+
+  LOGMPRIS("The image file is created at %s", mMPRISMetadata.mArtUrl.get());
+  return EmitMetadataChanged();
+}
+
+bool MPRISServiceHandler::RenewLocalImageFile(const char* aImageData,
+                                              uint32_t aDataSize) {
+  MOZ_ASSERT(aImageData);
+  MOZ_ASSERT(aDataSize != 0);
+
+  if (!InitLocalImageFile()) {
+    LOGMPRIS("Failed to create a new image");
+    return false;
+  }
+
+  MOZ_ASSERT(mLocalImageFile);
+  nsCOMPtr<nsIOutputStream> out;
+  NS_NewLocalFileOutputStream(getter_AddRefs(out), mLocalImageFile,
+                              PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE);
+  uint32_t written;
+  nsresult rv = out->Write(aImageData, aDataSize, &written);
+  if (NS_FAILED(rv) || written != aDataSize) {
+    LOGMPRIS("Failed to write an image file");
+    RemoveAllLocalImages();
+    return false;
+  }
+
+  return true;
+}
+
+static const char* GetImageFileExtension(const char* aMimeType) {
+  MOZ_ASSERT(strcmp(aMimeType, IMAGE_PNG) == 0);
+  return "png";
+}
+
+bool MPRISServiceHandler::InitLocalImageFile() {
+  RemoveAllLocalImages();
+
+  if (!InitLocalImageFolder()) {
+    return false;
+  }
+
+  MOZ_ASSERT(mLocalImageFolder);
+  MOZ_ASSERT(!mLocalImageFile);
+  nsresult rv = mLocalImageFolder->Clone(getter_AddRefs(mLocalImageFile));
+  if (NS_FAILED(rv)) {
+    LOGMPRIS("Failed to get the image folder");
+    return false;
+  }
+
+  auto cleanup =
+      MakeScopeExit([this, self = RefPtr<MPRISServiceHandler>(this)] {
+        mLocalImageFile = nullptr;
+      });
+
+  // Create an unique file name to work around the file caching mechanism in the
+  // Ubuntu. Once the image X specified by the filename Y is used in Ubuntu's
+  // MPRIS, this pair will be cached. As long as the filename is same, even the
+  // file content specified by Y is changed to Z, the image will stay unchanged.
+  // The image shown in the Ubuntu's notification is still X instead of Z.
+  // Changing the filename constantly works around this problem
+  char filename[64];
+  SprintfLiteral(filename, "%d_%d.%s", getpid(), gImageNumber++,
+                 GetImageFileExtension(mMimeType.get()));
+
+  rv = mLocalImageFile->Append(NS_ConvertUTF8toUTF16(filename));
+  if (NS_FAILED(rv)) {
+    LOGMPRIS("Failed to create an image filename");
+    return false;
+  }
+
+  rv = mLocalImageFile->Create(nsIFile::NORMAL_FILE_TYPE, 0600);
+  if (NS_FAILED(rv)) {
+    LOGMPRIS("Failed to create an image file");
+    return false;
+  }
+
+  cleanup.release();
+  return true;
+}
+
+bool MPRISServiceHandler::InitLocalImageFolder() {
+  if (mLocalImageFolder && LocalImageFolderExists()) {
+    return true;
+  }
+
+  nsresult rv = NS_ERROR_FAILURE;
+  if (IsRunningUnderFlatpak()) {
+    // The XDG_DATA_HOME points to the same location in the host and guest
+    // filesystem.
+    if (const auto* xdgDataHome = g_getenv("XDG_DATA_HOME")) {
+      rv = NS_NewNativeLocalFile(nsDependentCString(xdgDataHome), true,
+                                 getter_AddRefs(mLocalImageFolder));
+    }
+  } else {
+    rv = NS_GetSpecialDirectory(XRE_USER_APP_DATA_DIR,
+                                getter_AddRefs(mLocalImageFolder));
+  }
+
+  if (NS_FAILED(rv) || !mLocalImageFolder) {
+    LOGMPRIS("Failed to get the image folder");
+    return false;
+  }
+
+  auto cleanup = MakeScopeExit([&] { mLocalImageFolder = nullptr; });
+
+  rv = mLocalImageFolder->Append(u"firefox-mpris"_ns);
+  if (NS_FAILED(rv)) {
+    LOGMPRIS("Failed to name an image folder");
+    return false;
+  }
+
+  if (!LocalImageFolderExists()) {
+    rv = mLocalImageFolder->Create(nsIFile::DIRECTORY_TYPE, 0700);
+    if (NS_FAILED(rv)) {
+      LOGMPRIS("Failed to create an image folder");
+      return false;
+    }
+  }
+
+  cleanup.release();
+  return true;
+}
+
+void MPRISServiceHandler::RemoveAllLocalImages() {
+  if (!mLocalImageFolder || !LocalImageFolderExists()) {
+    return;
+  }
+
+  nsresult rv = mLocalImageFolder->Remove(/* aRecursive */ true);
+  if (NS_FAILED(rv)) {
+    // It's ok to fail. The next removal is called when updating the
+    // media-session image, or closing the MPRIS.
+    LOGMPRIS("Failed to remove images");
+  }
+
+  LOGMPRIS("Abandon %s",
+           mLocalImageFile ? mLocalImageFile->NativePath().get() : "nothing");
+  mMPRISMetadata.mArtUrl.Truncate();
+  mLocalImageFile = nullptr;
+  mLocalImageFolder = nullptr;
+}
+
+bool MPRISServiceHandler::LocalImageFolderExists() {
+  MOZ_ASSERT(mLocalImageFolder);
+
+  bool exists;
+  nsresult rv = mLocalImageFolder->Exists(&exists);
+  return NS_SUCCEEDED(rv) && exists;
+}
+
+GVariant* MPRISServiceHandler::GetMetadataAsGVariant() const {
+  GVariantBuilder builder;
+  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
+  g_variant_builder_add(&builder, "{sv}", "mpris:trackid",
+                        g_variant_new("o", DBUS_MPRIS_TRACK_PATH));
+
+  g_variant_builder_add(
+      &builder, "{sv}", "xesam:title",
+      g_variant_new_string(static_cast<const gchar*>(
+          NS_ConvertUTF16toUTF8(mMPRISMetadata.mTitle).get())));
+
+  g_variant_builder_add(
+      &builder, "{sv}", "xesam:album",
+      g_variant_new_string(static_cast<const gchar*>(
+          NS_ConvertUTF16toUTF8(mMPRISMetadata.mAlbum).get())));
+
+  GVariantBuilder artistBuilder;
+  g_variant_builder_init(&artistBuilder, G_VARIANT_TYPE("as"));
+  g_variant_builder_add(
+      &artistBuilder, "s",
+      static_cast<const gchar*>(
+          NS_ConvertUTF16toUTF8(mMPRISMetadata.mArtist).get()));
+  g_variant_builder_add(&builder, "{sv}", "xesam:artist",
+                        g_variant_builder_end(&artistBuilder));
+
+  if (!mMPRISMetadata.mArtUrl.IsEmpty()) {
+    g_variant_builder_add(&builder, "{sv}", "mpris:artUrl",
+                          g_variant_new_string(static_cast<const gchar*>(
+                              mMPRISMetadata.mArtUrl.get())));
+  }
+
+  return g_variant_builder_end(&builder);
+}
+
+void MPRISServiceHandler::EmitEvent(dom::MediaControlKey aKey) const {
+  for (const auto& listener : mListeners) {
+    listener->OnActionPerformed(dom::MediaControlAction(aKey));
+  }
+}
+
+struct InterfaceProperty {
+  const char* interface;
+  const char* property;
+};
+static const std::unordered_map<dom::MediaControlKey, InterfaceProperty>
+    gKeyProperty = {
+        {dom::MediaControlKey::Focus, {DBUS_MPRIS_INTERFACE, "CanRaise"}},
+        {dom::MediaControlKey::Nexttrack,
+         {DBUS_MPRIS_PLAYER_INTERFACE, "CanGoNext"}},
+        {dom::MediaControlKey::Previoustrack,
+         {DBUS_MPRIS_PLAYER_INTERFACE, "CanGoPrevious"}},
+        {dom::MediaControlKey::Play, {DBUS_MPRIS_PLAYER_INTERFACE, "CanPlay"}},
+        {dom::MediaControlKey::Pause,
+         {DBUS_MPRIS_PLAYER_INTERFACE, "CanPause"}}};
+
+void MPRISServiceHandler::SetSupportedMediaKeys(
+    const MediaKeysArray& aSupportedKeys) {
+  uint32_t supportedKeys = 0;
+  for (const dom::MediaControlKey& key : aSupportedKeys) {
+    supportedKeys |= GetMediaKeyMask(key);
+  }
+
+  if (mSupportedKeys == supportedKeys) {
+    LOGMPRIS("Supported keys stay the same");
+    return;
+  }
+
+  uint32_t oldSupportedKeys = mSupportedKeys;
+  mSupportedKeys = supportedKeys;
+
+  // Emit related property changes
+  for (auto it : gKeyProperty) {
+    bool keyWasSupported = oldSupportedKeys & GetMediaKeyMask(it.first);
+    bool keyIsSupported = mSupportedKeys & GetMediaKeyMask(it.first);
+    if (keyWasSupported != keyIsSupported) {
+      LOGMPRIS("Emit PropertiesChanged signal: %s.%s=%s", it.second.interface,
+               it.second.property, keyIsSupported ? "true" : "false");
+      EmitSupportedKeyChanged(it.first, keyIsSupported);
+    }
+  }
+}
+
+bool MPRISServiceHandler::IsMediaKeySupported(dom::MediaControlKey aKey) const {
+  return mSupportedKeys & GetMediaKeyMask(aKey);
+}
+
+bool MPRISServiceHandler::EmitSupportedKeyChanged(dom::MediaControlKey aKey,
+                                                  bool aSupported) const {
+  auto it = gKeyProperty.find(aKey);
+  if (it == gKeyProperty.end()) {
+    LOGMPRIS("No property for %s", ToMediaControlKeyStr(aKey));
+    return false;
+  }
+
+  GVariantBuilder builder;
+  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
+  g_variant_builder_add(&builder, "{sv}",
+                        static_cast<const gchar*>(it->second.property),
+                        g_variant_new_boolean(aSupported));
+
+  GVariant* parameters = g_variant_new(
+      "(sa{sv}as)", static_cast<const gchar*>(it->second.interface), &builder,
+      nullptr);
+
+  LOGMPRIS("Emit MPRIS property changes for '%s.%s'", it->second.interface,
+           it->second.property);
+  return EmitPropertiesChangedSignal(parameters);
+}
+
+bool MPRISServiceHandler::EmitPropertiesChangedSignal(
+    GVariant* aParameters) const {
+  if (!mConnection) {
+    LOGMPRIS("No D-Bus Connection. Cannot emit properties changed signal");
+    return false;
+  }
+
+  GError* error = nullptr;
+  if (!g_dbus_connection_emit_signal(
+          mConnection, nullptr, DBUS_MPRIS_OBJECT_PATH,
+          "org.freedesktop.DBus.Properties", "PropertiesChanged", aParameters,
+          &error)) {
+    LOGMPRIS("Failed to emit MPRIS property changes: %s",
+             error ? error->message : "Unknown Error");
+    if (error) {
+      g_error_free(error);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+#undef LOGMPRIS
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/MPRISServiceHandler.h b/widget/gtk/MPRISServiceHandler.h
new file mode 100644
index 0000000000..f2b171c87e
--- /dev/null
+++ b/widget/gtk/MPRISServiceHandler.h
@@ -0,0 +1,187 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WIDGET_GTK_MPRIS_SERVICE_HANDLER_H_
+#define WIDGET_GTK_MPRIS_SERVICE_HANDLER_H_
+
+#include <gio/gio.h>
+#include "mozilla/dom/FetchImageHelper.h"
+#include "mozilla/dom/MediaControlKeySource.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/UniquePtr.h"
+#include "nsIFile.h"
+#include "nsMimeTypes.h"
+#include "nsString.h"
+
+#define DBUS_MPRIS_SERVICE_NAME "org.mpris.MediaPlayer2.firefox"
+#define DBUS_MPRIS_OBJECT_PATH "/org/mpris/MediaPlayer2"
+#define DBUS_MPRIS_INTERFACE "org.mpris.MediaPlayer2"
+#define DBUS_MPRIS_PLAYER_INTERFACE "org.mpris.MediaPlayer2.Player"
+#define DBUS_MPRIS_TRACK_PATH "/org/mpris/MediaPlayer2/firefox"
+
+namespace mozilla {
+namespace widget {
+
+/**
+ * This class implements the "MPRIS" D-Bus Service
+ * (https://specifications.freedesktop.org/mpris-spec/2.2),
+ * which is used to communicate with the Desktop Environment about the
+ * Multimedia playing in Gecko.
+ * Note that this interface requires many methods which may not be supported by
+ * Gecko, the interface
+ * however provides CanXYZ properties for these methods, so the method is
+ * defined but won't be executed.
+ *
+ * Also note that the following defines are for parts that the MPRIS Spec
+ * defines optional. The code won't
+ * compile with any of the defines set, yet, as those aren't implemented yet and
+ * probably never will be of
+ * use for gecko. For sake of completeness, they have been added until the
+ * decision about their implementation
+ * is finally made.
+ *
+ * The constexpr'ed methods are capabilities of the user agent known at compile
+ * time, e.g. we decided at
+ * compile time whether we ever want to support closing the user agent via MPRIS
+ * (Quit() and CanQuit()).
+ *
+ * Other properties like CanPlay() might depend on the runtime state (is there
+ * media available for playback?)
+ * and thus aren't a constexpr but merely a const method.
+ */
+class MPRISServiceHandler final : public dom::MediaControlKeySource {
+  NS_INLINE_DECL_REFCOUNTING(MPRISServiceHandler, override)
+ public:
+  // Note that this constructor does NOT initialize the MPRIS Service but only
+  // this class. The method Open() is responsible for registering and MAY FAIL.
+
+  MPRISServiceHandler();
+  bool Open() override;
+  void Close() override;
+  bool IsOpened() const override;
+
+  // From the EventSource.
+  void SetPlaybackState(dom::MediaSessionPlaybackState aState) override;
+
+  // GetPlaybackState returns dom::PlaybackState. GetPlaybackStatus returns this
+  // state converted into d-bus variants.
+  GVariant* GetPlaybackStatus() const;
+
+  const char* Identity() const;
+  const char* DesktopEntry() const;
+  bool PressKey(dom::MediaControlKey aKey) const;
+
+  void SetMediaMetadata(const dom::MediaMetadataBase& aMetadata) override;
+  GVariant* GetMetadataAsGVariant() const;
+
+  void SetSupportedMediaKeys(const MediaKeysArray& aSupportedKeys) override;
+
+  bool IsMediaKeySupported(dom::MediaControlKey aKey) const;
+
+ private:
+  ~MPRISServiceHandler();
+
+  // Note: Registration Ids for the D-Bus start with 1, so a value of 0
+  // indicates an error (or an object which wasn't initialized yet)
+
+  // a handle to our bus registration/ownership
+  guint mOwnerId = 0;
+  // This is for the interface org.mpris.MediaPlayer2
+  guint mRootRegistrationId = 0;
+  // This is for the interface org.mpris.MediaPlayer2.Player
+  guint mPlayerRegistrationId = 0;
+  RefPtr<GDBusNodeInfo> mIntrospectionData;
+  GDBusConnection* mConnection = nullptr;
+  bool mInitialized = false;
+  nsAutoCString mIdentity;
+  nsAutoCString mDesktopEntry;
+
+  // The image format used in MPRIS is based on the mMimeType here. Although
+  // IMAGE_JPEG or IMAGE_BMP are valid types as well but a png image with
+  // transparent background will be converted into a jpeg/bmp file with a
+  // colored background IMAGE_PNG format seems to be the best choice for now.
+  nsCString mMimeType{IMAGE_PNG};
+
+  // A bitmask indicating what keys are enabled
+  uint32_t mSupportedKeys = 0;
+
+  class MPRISMetadata : public dom::MediaMetadataBase {
+   public:
+    MPRISMetadata() = default;
+    ~MPRISMetadata() = default;
+
+    void UpdateFromMetadataBase(const dom::MediaMetadataBase& aMetadata) {
+      mTitle = aMetadata.mTitle;
+      mArtist = aMetadata.mArtist;
+      mAlbum = aMetadata.mAlbum;
+      mArtwork = aMetadata.mArtwork;
+    }
+    void Clear() {
+      UpdateFromMetadataBase(MediaMetadataBase::EmptyData());
+      mArtUrl.Truncate();
+    }
+
+    nsCString mArtUrl;
+  };
+  MPRISMetadata mMPRISMetadata;
+
+  // The saved image file fetched from the URL
+  nsCOMPtr<nsIFile> mLocalImageFile;
+  nsCOMPtr<nsIFile> mLocalImageFolder;
+
+  UniquePtr<dom::FetchImageHelper> mImageFetcher;
+  MozPromiseRequestHolder<dom::ImagePromise> mImageFetchRequest;
+
+  nsString mFetchingUrl;
+  nsString mCurrentImageUrl;
+
+  size_t mNextImageIndex = 0;
+
+  // Load the image at index aIndex of the metadta's artwork to MPRIS
+  // asynchronously
+  void LoadImageAtIndex(const size_t aIndex);
+  bool SetImageToDisplay(const char* aImageData, uint32_t aDataSize);
+
+  bool RenewLocalImageFile(const char* aImageData, uint32_t aDataSize);
+  bool InitLocalImageFile();
+  bool InitLocalImageFolder();
+  void RemoveAllLocalImages();
+  bool LocalImageFolderExists();
+
+  // Queries nsAppInfo to get the branded browser name and vendor
+  void InitIdentity();
+
+  // non-public API, called from events
+  void OnNameAcquired(GDBusConnection* aConnection, const gchar* aName);
+  void OnNameLost(GDBusConnection* aConnection, const gchar* aName);
+  void OnBusAcquired(GDBusConnection* aConnection, const gchar* aName);
+
+  static void OnNameAcquiredStatic(GDBusConnection* aConnection,
+                                   const gchar* aName, gpointer aUserData);
+  static void OnNameLostStatic(GDBusConnection* aConnection, const gchar* aName,
+                               gpointer aUserData);
+  static void OnBusAcquiredStatic(GDBusConnection* aConnection,
+                                  const gchar* aName, gpointer aUserData);
+
+  void EmitEvent(dom::MediaControlKey aKey) const;
+
+  bool EmitMetadataChanged() const;
+
+  void SetMediaMetadataInternal(const dom::MediaMetadataBase& aMetadata,
+                                bool aClearArtUrl = true);
+
+  bool EmitSupportedKeyChanged(dom::MediaControlKey aKey,
+                               bool aSupported) const;
+
+  bool EmitPropertiesChangedSignal(GVariant* aParameters) const;
+
+  void ClearMetadata();
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // WIDGET_GTK_MPRIS_SERVICE_HANDLER_H_
diff --git a/widget/gtk/MediaKeysEventSourceFactory.cpp b/widget/gtk/MediaKeysEventSourceFactory.cpp
new file mode 100644
index 0000000000..b9a3dfde41
--- /dev/null
+++ b/widget/gtk/MediaKeysEventSourceFactory.cpp
@@ -0,0 +1,14 @@
+/* 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 "MediaKeysEventSourceFactory.h"
+#include "MPRISServiceHandler.h"
+
+namespace mozilla::widget {
+
+mozilla::dom::MediaControlKeySource* CreateMediaControlKeySource() {
+  return new MPRISServiceHandler();
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/MozContainer.cpp b/widget/gtk/MozContainer.cpp
new file mode 100644
index 0000000000..881e90d054
--- /dev/null
+++ b/widget/gtk/MozContainer.cpp
@@ -0,0 +1,386 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MozContainer.h"
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <stdio.h>
+#include "mozilla/WidgetUtilsGtk.h"
+
+#ifdef ACCESSIBILITY
+#  include <atk/atk.h>
+#  include "maiRedundantObjectFactory.h"
+#endif
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gWidgetLog;
+#  define LOGCONTAINER(args) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, args)
+#else
+#  define LOGCONTAINER(args)
+#endif /* MOZ_LOGGING */
+
+/* init methods */
+static void moz_container_class_init(MozContainerClass* klass);
+static void moz_container_init(MozContainer* container);
+
+/* widget class methods */
+static void moz_container_map(GtkWidget* widget);
+void moz_container_unmap(GtkWidget* widget);
+static void moz_container_size_allocate(GtkWidget* widget,
+                                        GtkAllocation* allocation);
+void moz_container_realize(GtkWidget* widget);
+
+/* container class methods */
+static void moz_container_remove(GtkContainer* container,
+                                 GtkWidget* child_widget);
+static void moz_container_forall(GtkContainer* container,
+                                 gboolean include_internals,
+                                 GtkCallback callback, gpointer callback_data);
+static void moz_container_add(GtkContainer* container, GtkWidget* widget);
+
+typedef struct _MozContainerChild MozContainerChild;
+
+struct _MozContainerChild {
+  GtkWidget* widget;
+  gint x;
+  gint y;
+};
+
+static void moz_container_allocate_child(MozContainer* container,
+                                         MozContainerChild* child);
+static MozContainerChild* moz_container_get_child(MozContainer* container,
+                                                  GtkWidget* child);
+
+/* public methods */
+
+GType moz_container_get_type(void) {
+  static GType moz_container_type = 0;
+
+  if (!moz_container_type) {
+    static GTypeInfo moz_container_info = {
+        sizeof(MozContainerClass),                /* class_size */
+        NULL,                                     /* base_init */
+        NULL,                                     /* base_finalize */
+        (GClassInitFunc)moz_container_class_init, /* class_init */
+        NULL,                                     /* class_destroy */
+        NULL,                                     /* class_data */
+        sizeof(MozContainer),                     /* instance_size */
+        0,                                        /* n_preallocs */
+        (GInstanceInitFunc)moz_container_init,    /* instance_init */
+        NULL,                                     /* value_table */
+    };
+
+#ifdef MOZ_WAYLAND
+    if (mozilla::widget::GdkIsWaylandDisplay()) {
+      moz_container_info.class_init =
+          (GClassInitFunc)moz_container_wayland_class_init;
+    }
+#endif
+
+    moz_container_type =
+        g_type_register_static(GTK_TYPE_CONTAINER, "MozContainer",
+                               &moz_container_info, static_cast<GTypeFlags>(0));
+#ifdef ACCESSIBILITY
+    /* Set a factory to return accessible object with ROLE_REDUNDANT for
+     * MozContainer, so that gail won't send focus notification for it */
+    atk_registry_set_factory_type(atk_get_default_registry(),
+                                  moz_container_type,
+                                  mai_redundant_object_factory_get_type());
+#endif
+  }
+
+  return moz_container_type;
+}
+
+GtkWidget* moz_container_new(void) {
+  MozContainer* container;
+
+  container =
+      static_cast<MozContainer*>(g_object_new(MOZ_CONTAINER_TYPE, nullptr));
+
+  return GTK_WIDGET(container);
+}
+
+void moz_container_put(MozContainer* container, GtkWidget* child_widget, gint x,
+                       gint y) {
+  MozContainerChild* child;
+
+  child = g_new(MozContainerChild, 1);
+
+  child->widget = child_widget;
+  child->x = x;
+  child->y = y;
+
+  /*  printf("moz_container_put %p %p %d %d\n", (void *)container,
+      (void *)child_widget, x, y); */
+
+  container->children = g_list_append(container->children, child);
+
+  /* we assume that the caller of this function will have already set
+     the parent GdkWindow because we can have many anonymous children. */
+  gtk_widget_set_parent(child_widget, GTK_WIDGET(container));
+}
+
+void moz_container_class_init(MozContainerClass* klass) {
+  /*GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+    GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass); */
+  GtkContainerClass* container_class = GTK_CONTAINER_CLASS(klass);
+  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
+
+  widget_class->map = moz_container_map;
+  widget_class->realize = moz_container_realize;
+  widget_class->size_allocate = moz_container_size_allocate;
+
+  container_class->remove = moz_container_remove;
+  container_class->forall = moz_container_forall;
+  container_class->add = moz_container_add;
+}
+
+void moz_container_init(MozContainer* container) {
+  gtk_widget_set_can_focus(GTK_WIDGET(container), TRUE);
+  gtk_widget_set_redraw_on_allocate(GTK_WIDGET(container), FALSE);
+#ifdef MOZ_WAYLAND
+  if (mozilla::widget::GdkIsWaylandDisplay()) {
+    moz_container_wayland_init(&container->wl_container);
+  }
+#endif
+  LOGCONTAINER(("%s [%p]\n", __FUNCTION__,
+                (void*)moz_container_get_nsWindow(container)));
+}
+
+void moz_container_map(GtkWidget* widget) {
+  MozContainer* container;
+  GList* tmp_list;
+  GtkWidget* tmp_child;
+
+  g_return_if_fail(IS_MOZ_CONTAINER(widget));
+  container = MOZ_CONTAINER(widget);
+
+  LOGCONTAINER(("moz_container_map() [%p]",
+                (void*)moz_container_get_nsWindow(container)));
+
+  gtk_widget_set_mapped(widget, TRUE);
+
+  tmp_list = container->children;
+  while (tmp_list) {
+    tmp_child = ((MozContainerChild*)tmp_list->data)->widget;
+
+    if (gtk_widget_get_visible(tmp_child)) {
+      if (!gtk_widget_get_mapped(tmp_child)) gtk_widget_map(tmp_child);
+    }
+    tmp_list = tmp_list->next;
+  }
+
+  if (gtk_widget_get_has_window(widget)) {
+    gdk_window_show(gtk_widget_get_window(widget));
+  }
+}
+
+void moz_container_unmap(GtkWidget* widget) {
+  g_return_if_fail(IS_MOZ_CONTAINER(widget));
+
+  LOGCONTAINER(("moz_container_unmap() [%p]",
+                (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget))));
+
+  gtk_widget_set_mapped(widget, FALSE);
+
+  if (gtk_widget_get_has_window(widget)) {
+    gdk_window_hide(gtk_widget_get_window(widget));
+  }
+}
+
+void moz_container_realize(GtkWidget* widget) {
+  GdkWindow* parent = gtk_widget_get_parent_window(widget);
+  GdkWindow* window;
+
+  gtk_widget_set_realized(widget, TRUE);
+
+  if (gtk_widget_get_has_window(widget)) {
+    GdkWindowAttr attributes;
+    gint attributes_mask = GDK_WA_VISUAL | GDK_WA_X | GDK_WA_Y;
+    GtkAllocation allocation;
+
+    gtk_widget_get_allocation(widget, &allocation);
+    attributes.event_mask = gtk_widget_get_events(widget);
+    attributes.x = allocation.x;
+    attributes.y = allocation.y;
+    attributes.width = allocation.width;
+    attributes.height = allocation.height;
+    attributes.wclass = GDK_INPUT_OUTPUT;
+    attributes.window_type = GDK_WINDOW_CHILD;
+    MozContainer* container = MOZ_CONTAINER(widget);
+    attributes.visual =
+        container->force_default_visual
+            ? gdk_screen_get_system_visual(gtk_widget_get_screen(widget))
+            : gtk_widget_get_visual(widget);
+
+    window = gdk_window_new(parent, &attributes, attributes_mask);
+
+    LOGCONTAINER(("moz_container_realize() [%p] GdkWindow %p\n",
+                  (void*)moz_container_get_nsWindow(container), (void*)window));
+
+    gdk_window_set_user_data(window, widget);
+  } else {
+    window = parent;
+    g_object_ref(window);
+  }
+
+  gtk_widget_set_window(widget, window);
+}
+
+void moz_container_size_allocate(GtkWidget* widget, GtkAllocation* allocation) {
+  MozContainer* container;
+  GList* tmp_list;
+  GtkAllocation tmp_allocation;
+
+  g_return_if_fail(IS_MOZ_CONTAINER(widget));
+
+  LOGCONTAINER(("moz_container_size_allocate [%p] %d,%d -> %d x %d\n",
+                (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget)),
+                allocation->x, allocation->y, allocation->width,
+                allocation->height));
+
+  /* short circuit if you can */
+  container = MOZ_CONTAINER(widget);
+  gtk_widget_get_allocation(widget, &tmp_allocation);
+  if (!container->children && tmp_allocation.x == allocation->x &&
+      tmp_allocation.y == allocation->y &&
+      tmp_allocation.width == allocation->width &&
+      tmp_allocation.height == allocation->height) {
+    return;
+  }
+
+  gtk_widget_set_allocation(widget, allocation);
+
+  tmp_list = container->children;
+
+  while (tmp_list) {
+    MozContainerChild* child = static_cast<MozContainerChild*>(tmp_list->data);
+
+    moz_container_allocate_child(container, child);
+
+    tmp_list = tmp_list->next;
+  }
+
+  if (gtk_widget_get_has_window(widget) && gtk_widget_get_realized(widget)) {
+    gdk_window_move_resize(gtk_widget_get_window(widget), allocation->x,
+                           allocation->y, allocation->width,
+                           allocation->height);
+  }
+}
+
+void moz_container_remove(GtkContainer* container, GtkWidget* child_widget) {
+  MozContainerChild* child;
+  MozContainer* moz_container;
+  GdkWindow* parent_window;
+
+  g_return_if_fail(IS_MOZ_CONTAINER(container));
+  g_return_if_fail(GTK_IS_WIDGET(child_widget));
+
+  moz_container = MOZ_CONTAINER(container);
+
+  child = moz_container_get_child(moz_container, child_widget);
+  g_return_if_fail(child);
+
+  /* gtk_widget_unparent will remove the parent window (as well as the
+   * parent widget), but, in Mozilla's window hierarchy, the parent window
+   * may need to be kept because it may be part of a GdkWindow sub-hierarchy
+   * that is being moved to another MozContainer.
+   *
+   * (In a conventional GtkWidget hierarchy, GdkWindows being reparented
+   * would have their own GtkWidget and that widget would be the one being
+   * reparented.  In Mozilla's hierarchy, the parent_window needs to be
+   * retained so that the GdkWindow sub-hierarchy is maintained.)
+   */
+  parent_window = gtk_widget_get_parent_window(child_widget);
+  if (parent_window) g_object_ref(parent_window);
+
+  gtk_widget_unparent(child_widget);
+
+  if (parent_window) {
+    /* The child_widget will always still exist because g_signal_emit,
+     * which invokes this function, holds a reference.
+     *
+     * If parent_window is the container's root window then it will not be
+     * the parent_window if the child_widget is placed in another
+     * container.
+     */
+    if (parent_window != gtk_widget_get_window(GTK_WIDGET(container)))
+      gtk_widget_set_parent_window(child_widget, parent_window);
+
+    g_object_unref(parent_window);
+  }
+
+  moz_container->children = g_list_remove(moz_container->children, child);
+  g_free(child);
+}
+
+void moz_container_forall(GtkContainer* container, gboolean include_internals,
+                          GtkCallback callback, gpointer callback_data) {
+  MozContainer* moz_container;
+  GList* tmp_list;
+
+  g_return_if_fail(IS_MOZ_CONTAINER(container));
+  g_return_if_fail(callback != NULL);
+
+  moz_container = MOZ_CONTAINER(container);
+
+  tmp_list = moz_container->children;
+  while (tmp_list) {
+    MozContainerChild* child;
+    child = static_cast<MozContainerChild*>(tmp_list->data);
+    tmp_list = tmp_list->next;
+    (*callback)(child->widget, callback_data);
+  }
+}
+
+static void moz_container_allocate_child(MozContainer* container,
+                                         MozContainerChild* child) {
+  GtkAllocation allocation;
+
+  gtk_widget_get_allocation(child->widget, &allocation);
+  allocation.x = child->x;
+  allocation.y = child->y;
+
+  gtk_widget_size_allocate(child->widget, &allocation);
+}
+
+MozContainerChild* moz_container_get_child(MozContainer* container,
+                                           GtkWidget* child_widget) {
+  GList* tmp_list;
+
+  tmp_list = container->children;
+  while (tmp_list) {
+    MozContainerChild* child;
+
+    child = static_cast<MozContainerChild*>(tmp_list->data);
+    tmp_list = tmp_list->next;
+
+    if (child->widget == child_widget) return child;
+  }
+
+  return NULL;
+}
+
+static void moz_container_add(GtkContainer* container, GtkWidget* widget) {
+  moz_container_put(MOZ_CONTAINER(container), widget, 0, 0);
+}
+
+void moz_container_force_default_visual(MozContainer* container) {
+  container->force_default_visual = true;
+}
+
+nsWindow* moz_container_get_nsWindow(MozContainer* container) {
+  gpointer user_data = g_object_get_data(G_OBJECT(container), "nsWindow");
+  return static_cast<nsWindow*>(user_data);
+}
+
+#undef LOGCONTAINER
diff --git a/widget/gtk/MozContainer.h b/widget/gtk/MozContainer.h
new file mode 100644
index 0000000000..6d4465f189
--- /dev/null
+++ b/widget/gtk/MozContainer.h
@@ -0,0 +1,90 @@
+/* -*- 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_CONTAINER_H__
+#define __MOZ_CONTAINER_H__
+
+#ifdef MOZ_WAYLAND
+#  include "MozContainerWayland.h"
+#endif
+
+#include <gtk/gtk.h>
+#include <functional>
+
+/*
+ * MozContainer
+ *
+ * This class serves three purposes in the nsIWidget implementation.
+ *
+ *   - It provides objects to receive signals from GTK for events on native
+ *     windows.
+ *
+ *   - It provides GdkWindow to draw content on Wayland or when Gtk+ renders
+ *     client side decorations to mShell.
+ *
+ *   - It provides a container parent for GtkWidgets.  The only GtkWidgets
+ *     that need this in Mozilla are the GtkSockets for windowed plugins (Xt
+ *     and XEmbed).
+ *
+ * Note that the window hierarchy in Mozilla differs from conventional
+ * GtkWidget hierarchies.
+ *
+ * Mozilla's hierarchy exists through the GdkWindow hierarchy, and all child
+ * GdkWindows (within a child nsIWidget hierarchy) belong to one MozContainer
+ * GtkWidget.  If the MozContainer is unrealized or its GdkWindows are
+ * destroyed for some other reason, then the hierarchy no longer exists.  (In
+ * conventional GTK clients, the hierarchy is recorded by the GtkWidgets, and
+ * so can be re-established after destruction of the GdkWindows.)
+ *
+ * One consequence of this is that the MozContainer does not know which of its
+ * GdkWindows should parent child GtkWidgets.  (Conventional GtkContainers
+ * determine which GdkWindow to assign child GtkWidgets.)
+ *
+ * Therefore, when adding a child GtkWidget to a MozContainer,
+ * gtk_widget_set_parent_window should be called on the child GtkWidget before
+ * it is realized.
+ */
+
+#define MOZ_CONTAINER_TYPE (moz_container_get_type())
+#define MOZ_CONTAINER(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), MOZ_CONTAINER_TYPE, MozContainer))
+#define MOZ_CONTAINER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), MOZ_CONTAINER_TYPE, MozContainerClass))
+#define IS_MOZ_CONTAINER(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), MOZ_CONTAINER_TYPE))
+#define IS_MOZ_CONTAINER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), MOZ_CONTAINER_TYPE))
+#define MOZ_CONTAINER_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS((obj), MOZ_CONTAINER_TYPE, MozContainerClass))
+
+typedef struct _MozContainer MozContainer;
+typedef struct _MozContainerClass MozContainerClass;
+
+struct _MozContainer {
+  GtkContainer container;
+  GList* children;
+  gboolean force_default_visual;
+#ifdef MOZ_WAYLAND
+  MozContainerWayland wl_container;
+#endif
+};
+
+struct _MozContainerClass {
+  GtkContainerClass parent_class;
+};
+
+GType moz_container_get_type(void);
+GtkWidget* moz_container_new(void);
+void moz_container_unmap(GtkWidget* widget);
+void moz_container_put(MozContainer* container, GtkWidget* child_widget, gint x,
+                       gint y);
+void moz_container_force_default_visual(MozContainer* container);
+
+class nsWindow;
+nsWindow* moz_container_get_nsWindow(MozContainer* container);
+
+#endif /* __MOZ_CONTAINER_H__ */
diff --git a/widget/gtk/MozContainerWayland.cpp b/widget/gtk/MozContainerWayland.cpp
new file mode 100644
index 0000000000..2a4a492077
--- /dev/null
+++ b/widget/gtk/MozContainerWayland.cpp
@@ -0,0 +1,812 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/*
+ * MozContainerWayland is a wrapper over MozContainer which provides
+ * wl_surface for MozContainer widget.
+ *
+ * The widget scheme looks like:
+ *
+ *   ---------------------------------------------------------
+ *  |  mShell Gtk widget (contains wl_surface owned by Gtk+)  |
+ *  |                                                         |
+ *  |  ---------------------------------------------------    |
+ *  | | mContainer (contains wl_surface owned by Gtk+)    |   |
+ *  | |                                                   |   |
+ *  | |  ---------------------------------------------    |   |
+ *  | | | wl_subsurface (attached to wl_surface       |   |   |
+ *  | | |                of mContainer)               |   |   |
+ *  | | |                                             |   |   |
+ *  | | |                                             |   |   |
+ *  | |  ---------------------------------------------    |   |
+ *  |  ---------------------------------------------------    |
+ *   ---------------------------------------------------------
+ *
+ *  We draw to wl_subsurface owned by MozContainerWayland.
+ *  We need to wait until wl_surface of mContainer is created
+ *  and then we create and attach our wl_subsurface to it.
+ *
+ *  First wl_subsurface creation has these steps:
+ *
+ *  1) moz_container_wayland_size_allocate() handler is called when
+ *     mContainer size/position is known.
+ *     It calls moz_container_wayland_surface_create_locked(), registers
+ *     a frame callback handler
+ *     moz_container_wayland_frame_callback_handler().
+ *
+ *  2) moz_container_wayland_frame_callback_handler() is called
+ *     when wl_surface owned by mozContainer is ready.
+ *     We call initial_draw_cbs() handler and we can create our wl_subsurface
+ *     on top of wl_surface owned by mozContainer.
+ *
+ *  When MozContainer hides/show again, moz_container_wayland_size_allocate()
+ *  handler may not be called as MozContainer size is set. So after first
+ *  show/hide sequence use moz_container_wayland_map_event() to create
+ *  wl_subsurface of MozContainer.
+ */
+
+#include "MozContainer.h"
+
+#include <dlfcn.h>
+#include <glib.h>
+#include <stdio.h>
+#include <wayland-egl.h>
+
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "nsGtkUtils.h"
+#include "nsWaylandDisplay.h"
+#include "base/task.h"
+
+#ifdef MOZ_LOGGING
+
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+#  include "nsWindow.h"
+extern mozilla::LazyLogModule gWidgetWaylandLog;
+extern mozilla::LazyLogModule gWidgetLog;
+#  define LOGWAYLAND(...) \
+    MOZ_LOG(gWidgetWaylandLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#  define LOGCONTAINER(...) \
+    MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#else
+#  define LOGWAYLAND(...)
+#  define LOGCONTAINER(...)
+#endif /* MOZ_LOGGING */
+
+using namespace mozilla;
+using namespace mozilla::widget;
+
+/* init methods */
+static void moz_container_wayland_destroy(GtkWidget* widget);
+
+/* widget class methods */
+static void moz_container_wayland_map(GtkWidget* widget);
+static gboolean moz_container_wayland_map_event(GtkWidget* widget,
+                                                GdkEventAny* event);
+static void moz_container_wayland_size_allocate(GtkWidget* widget,
+                                                GtkAllocation* allocation);
+static bool moz_container_wayland_surface_create_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container);
+static void moz_container_wayland_set_opaque_region_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container);
+
+// Lock mozcontainer and get wayland surface of it. You need to pair with
+// moz_container_wayland_surface_unlock() even
+// if moz_container_wayland_surface_lock() fails and returns nullptr.
+static struct wl_surface* moz_container_wayland_surface_lock(
+    MozContainer* container);
+static void moz_container_wayland_surface_unlock(MozContainer* container,
+                                                 struct wl_surface** surface);
+
+MozContainerSurfaceLock::MozContainerSurfaceLock(MozContainer* aContainer) {
+  mContainer = aContainer;
+  mSurface = moz_container_wayland_surface_lock(aContainer);
+}
+MozContainerSurfaceLock::~MozContainerSurfaceLock() {
+  moz_container_wayland_surface_unlock(mContainer, &mSurface);
+}
+struct wl_surface* MozContainerSurfaceLock::GetSurface() { return mSurface; }
+
+// Imlemented in MozContainer.cpp
+void moz_container_realize(GtkWidget* widget);
+
+// Invalidate gtk wl_surface to commit changes to wl_subsurface.
+// wl_subsurface changes are effective when parent surface is commited.
+static void moz_container_wayland_invalidate(MozContainer* container) {
+  LOGWAYLAND("moz_container_wayland_invalidate [%p]\n",
+             (void*)moz_container_get_nsWindow(container));
+
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
+  if (!window) {
+    LOGWAYLAND("    Failed - missing GdkWindow!\n");
+    return;
+  }
+  gdk_window_invalidate_rect(window, nullptr, true);
+}
+
+// Route input to parent wl_surface owned by Gtk+ so we get input
+// events from Gtk+.
+static void moz_container_clear_input_region(MozContainer* container) {
+  struct wl_compositor* compositor = WaylandDisplayGet()->GetCompositor();
+  MozContainerWayland* wl_container = &container->wl_container;
+  wl_region* region = wl_compositor_create_region(compositor);
+  wl_surface_set_input_region(wl_container->surface, region);
+  wl_region_destroy(region);
+}
+
+static void moz_container_wayland_move_locked(const MutexAutoLock& aProofOfLock,
+                                              MozContainer* container, int dx,
+                                              int dy) {
+  LOGCONTAINER("moz_container_wayland_move [%p] %d,%d\n",
+               (void*)moz_container_get_nsWindow(container), dx, dy);
+
+  MozContainerWayland* wl_container = &container->wl_container;
+  if (!wl_container->subsurface || (wl_container->subsurface_dx == dx &&
+                                    wl_container->subsurface_dy == dy)) {
+    return;
+  }
+
+  wl_container->subsurface_dx = dx;
+  wl_container->subsurface_dy = dy;
+  wl_subsurface_set_position(wl_container->subsurface,
+                             wl_container->subsurface_dx,
+                             wl_container->subsurface_dy);
+}
+
+// This is called from layout/compositor code only with
+// size equal to GL rendering context. Otherwise there are
+// rendering artifacts as wl_egl_window size does not match
+// GL rendering pipeline setup.
+void moz_container_wayland_egl_window_set_size(MozContainer* container,
+                                               nsIntSize aSize) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  MutexAutoLock lock(*wl_container->container_lock);
+  if (wl_container->eglwindow) {
+    wl_egl_window_resize(wl_container->eglwindow, aSize.width, aSize.height, 0,
+                         0);
+  }
+}
+
+void moz_container_wayland_class_init(MozContainerClass* klass) {
+  /*GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+    GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass); */
+  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
+
+  widget_class->map = moz_container_wayland_map;
+  widget_class->map_event = moz_container_wayland_map_event;
+  widget_class->destroy = moz_container_wayland_destroy;
+  widget_class->realize = moz_container_realize;
+  widget_class->size_allocate = moz_container_wayland_size_allocate;
+}
+
+void moz_container_wayland_init(MozContainerWayland* container) {
+  container->surface = nullptr;
+  container->subsurface = nullptr;
+  container->eglwindow = nullptr;
+  container->frame_callback_handler = nullptr;
+  container->viewport = nullptr;
+  container->ready_to_draw = false;
+  container->opaque_region_needs_updates = false;
+  container->opaque_region_corner_radius = 0;
+  container->opaque_region_used = false;
+  container->subsurface_dx = 0;
+  container->subsurface_dy = 0;
+  container->before_first_size_alloc = true;
+  container->buffer_scale = 1;
+  container->initial_draw_cbs.clear();
+  container->container_lock = new mozilla::Mutex("MozContainer lock");
+  container->commit_to_parent = false;
+  container->waiting_to_show = false;
+}
+
+static void moz_container_wayland_destroy(GtkWidget* widget) {
+  MozContainerWayland* container = &MOZ_CONTAINER(widget)->wl_container;
+  if (!container->container_lock) {
+    // moz_container_wayland_init was not called - it's a hidden container.
+    return;
+  }
+  moz_container_wayland_clear_initial_draw_callback(MOZ_CONTAINER(widget));
+  delete container->container_lock;
+  container->container_lock = nullptr;
+}
+
+void moz_container_wayland_add_initial_draw_callback_locked(
+    MozContainer* container, const std::function<void(void)>& initial_draw_cb) {
+  MozContainerWayland* wl_container = &MOZ_CONTAINER(container)->wl_container;
+
+  if (wl_container->ready_to_draw && !wl_container->surface) {
+    NS_WARNING(
+        "moz_container_wayland_add_or_fire_initial_draw_callback:"
+        " ready to draw without wayland surface!");
+  }
+  MOZ_DIAGNOSTIC_ASSERT(!wl_container->ready_to_draw || !wl_container->surface);
+  wl_container->initial_draw_cbs.push_back(initial_draw_cb);
+}
+
+void moz_container_wayland_add_or_fire_initial_draw_callback(
+    MozContainer* container, const std::function<void(void)>& initial_draw_cb) {
+  MozContainerWayland* wl_container = &MOZ_CONTAINER(container)->wl_container;
+  {
+    MutexAutoLock lock(*container->wl_container.container_lock);
+    if (wl_container->ready_to_draw && !wl_container->surface) {
+      NS_WARNING(
+          "moz_container_wayland_add_or_fire_initial_draw_callback: ready to "
+          "draw "
+          "without wayland surface!");
+    }
+    if (!wl_container->ready_to_draw || !wl_container->surface) {
+      wl_container->initial_draw_cbs.push_back(initial_draw_cb);
+      return;
+    }
+  }
+
+  // We're ready to draw as
+  // wl_container->ready_to_draw && wl_container->surface
+  // call the callback directly instead of store them.
+  initial_draw_cb();
+}
+
+static void moz_container_wayland_clear_initial_draw_callback_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container) {
+  MozContainerWayland* wl_container = &MOZ_CONTAINER(container)->wl_container;
+  MozClearPointer(wl_container->frame_callback_handler, wl_callback_destroy);
+  wl_container->initial_draw_cbs.clear();
+}
+
+void moz_container_wayland_clear_initial_draw_callback(
+    MozContainer* container) {
+  MutexAutoLock lock(*container->wl_container.container_lock);
+  moz_container_wayland_clear_initial_draw_callback_locked(lock, container);
+}
+
+static void moz_container_wayland_frame_callback_handler(
+    void* data, struct wl_callback* callback, uint32_t time) {
+  MozContainerWayland* wl_container = &MOZ_CONTAINER(data)->wl_container;
+
+  LOGWAYLAND(
+      "%s [%p] frame_callback_handler %p ready_to_draw %d (set to true)"
+      " initial_draw callback %zd\n",
+      __FUNCTION__, (void*)moz_container_get_nsWindow(MOZ_CONTAINER(data)),
+      (void*)wl_container->frame_callback_handler, wl_container->ready_to_draw,
+      wl_container->initial_draw_cbs.size());
+
+  std::vector<std::function<void(void)>> cbs;
+  {
+    // Protect mozcontainer internals changes by container_lock.
+    MutexAutoLock lock(*wl_container->container_lock);
+    MozClearPointer(wl_container->frame_callback_handler, wl_callback_destroy);
+    // It's possible that container is already unmapped so quit in such case.
+    if (!wl_container->surface) {
+      LOGWAYLAND("  container is unmapped, quit.");
+      if (!wl_container->initial_draw_cbs.empty()) {
+        NS_WARNING("Unmapping MozContainer with active draw callback!");
+        wl_container->initial_draw_cbs.clear();
+      }
+      return;
+    }
+    if (wl_container->ready_to_draw) {
+      return;
+    }
+    wl_container->ready_to_draw = true;
+    cbs = std::move(wl_container->initial_draw_cbs);
+  }
+
+  // Call the callbacks registered by
+  // moz_container_wayland_add_or_fire_initial_draw_callback().
+  // and we can't do that under mozcontainer lock.
+  for (auto const& cb : cbs) {
+    cb();
+  }
+}
+
+static const struct wl_callback_listener moz_container_frame_listener = {
+    moz_container_wayland_frame_callback_handler};
+
+static void after_frame_clock_after_paint(GdkFrameClock* clock,
+                                          MozContainer* container) {
+  MozContainerSurfaceLock lock(container);
+  struct wl_surface* surface = lock.GetSurface();
+  if (surface) {
+    wl_surface_commit(surface);
+  }
+}
+
+static bool moz_gdk_wayland_window_add_frame_callback_surface_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container) {
+  static auto sGdkWaylandWindowAddCallbackSurface =
+      (void (*)(GdkWindow*, struct wl_surface*))dlsym(
+          RTLD_DEFAULT, "gdk_wayland_window_add_frame_callback_surface");
+
+  if (!StaticPrefs::widget_wayland_opaque_region_enabled_AtStartup() ||
+      !sGdkWaylandWindowAddCallbackSurface) {
+    return false;
+  }
+
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
+  MozContainerWayland* wl_container = &container->wl_container;
+
+  sGdkWaylandWindowAddCallbackSurface(window, wl_container->surface);
+
+  GdkFrameClock* frame_clock = gdk_window_get_frame_clock(window);
+  g_signal_connect_after(frame_clock, "after-paint",
+                         G_CALLBACK(after_frame_clock_after_paint), container);
+  return true;
+}
+
+static void moz_gdk_wayland_window_remove_frame_callback_surface_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container) {
+  static auto sGdkWaylandWindowRemoveCallbackSurface =
+      (void (*)(GdkWindow*, struct wl_surface*))dlsym(
+          RTLD_DEFAULT, "gdk_wayland_window_remove_frame_callback_surface");
+
+  if (!sGdkWaylandWindowRemoveCallbackSurface) {
+    return;
+  }
+
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
+  MozContainerWayland* wl_container = &container->wl_container;
+
+  if (wl_container->surface) {
+    sGdkWaylandWindowRemoveCallbackSurface(window, wl_container->surface);
+  }
+
+  GdkFrameClock* frame_clock = gdk_window_get_frame_clock(window);
+  g_signal_handlers_disconnect_by_func(
+      frame_clock, FuncToGpointer(after_frame_clock_after_paint), container);
+}
+
+void moz_container_wayland_unmap(GtkWidget* widget) {
+  MozContainer* container = MOZ_CONTAINER(widget);
+  MozContainerWayland* wl_container = &container->wl_container;
+  MutexAutoLock lock(*wl_container->container_lock);
+
+  LOGCONTAINER("%s [%p]\n", __FUNCTION__,
+               (void*)moz_container_get_nsWindow(container));
+
+  moz_container_wayland_clear_initial_draw_callback_locked(lock, container);
+
+  if (wl_container->opaque_region_used) {
+    moz_gdk_wayland_window_remove_frame_callback_surface_locked(lock,
+                                                                container);
+  }
+  if (wl_container->commit_to_parent) {
+    wl_container->surface = nullptr;
+  }
+
+  MozClearPointer(wl_container->eglwindow, wl_egl_window_destroy);
+  MozClearPointer(wl_container->subsurface, wl_subsurface_destroy);
+  MozClearPointer(wl_container->surface, wl_surface_destroy);
+  MozClearPointer(wl_container->viewport, wp_viewport_destroy);
+
+  wl_container->ready_to_draw = false;
+  wl_container->buffer_scale = 1;
+}
+
+static gboolean moz_container_wayland_map_event(GtkWidget* widget,
+                                                GdkEventAny* event) {
+  MozContainerWayland* wl_container = &MOZ_CONTAINER(widget)->wl_container;
+
+  LOGCONTAINER("%s [%p]\n", __FUNCTION__,
+               (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget)));
+
+  // We need to mark MozContainer as mapped to make sure
+  // moz_container_wayland_unmap() is called on hide/withdraw.
+  gtk_widget_set_mapped(widget, TRUE);
+
+  // Make sure we're on main thread as we can't lock mozContainer here
+  // due to moz_container_wayland_add_or_fire_initial_draw_callback() call
+  // below.
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+
+  // Set waiting_to_show flag. It means the mozcontainer is cofigured/mapped
+  // and it's supposed to be visible. *But* it's really visible when we get
+  // moz_container_wayland_add_or_fire_initial_draw_callback() which means
+  // wayland compositor makes it live.
+  wl_container->waiting_to_show = true;
+  MozContainer* container = MOZ_CONTAINER(widget);
+  moz_container_wayland_add_or_fire_initial_draw_callback(
+      container, [container]() -> void {
+        LOGCONTAINER(
+            "[%p] moz_container_wayland_add_or_fire_initial_draw_callback set "
+            "visible",
+            moz_container_get_nsWindow(container));
+        moz_container_wayland_clear_waiting_to_show_flag(container);
+      });
+
+  MutexAutoLock lock(*wl_container->container_lock);
+
+  // Don't create wl_subsurface in map_event when it's already created or
+  // if we create it for the first time.
+  if (wl_container->ready_to_draw || wl_container->before_first_size_alloc) {
+    return FALSE;
+  }
+
+  if (!wl_container->surface) {
+    if (!moz_container_wayland_surface_create_locked(lock,
+                                                     MOZ_CONTAINER(widget))) {
+      return FALSE;
+    }
+  }
+
+  moz_container_wayland_set_scale_factor_locked(lock, MOZ_CONTAINER(widget));
+  moz_container_wayland_set_opaque_region_locked(lock, MOZ_CONTAINER(widget));
+  moz_container_clear_input_region(MOZ_CONTAINER(widget));
+  moz_container_wayland_invalidate(MOZ_CONTAINER(widget));
+  return FALSE;
+}
+
+void moz_container_wayland_map(GtkWidget* widget) {
+  LOGCONTAINER("%s [%p]\n", __FUNCTION__,
+               (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget)));
+
+  g_return_if_fail(IS_MOZ_CONTAINER(widget));
+  gtk_widget_set_mapped(widget, TRUE);
+
+  if (gtk_widget_get_has_window(widget)) {
+    gdk_window_show(gtk_widget_get_window(widget));
+  }
+}
+
+void moz_container_wayland_size_allocate(GtkWidget* widget,
+                                         GtkAllocation* allocation) {
+  MozContainer* container;
+  GtkAllocation tmp_allocation;
+
+  g_return_if_fail(IS_MOZ_CONTAINER(widget));
+
+  LOGCONTAINER("moz_container_wayland_size_allocate [%p] %d,%d -> %d x %d\n",
+               (void*)moz_container_get_nsWindow(MOZ_CONTAINER(widget)),
+               allocation->x, allocation->y, allocation->width,
+               allocation->height);
+
+  /* short circuit if you can */
+  container = MOZ_CONTAINER(widget);
+  gtk_widget_get_allocation(widget, &tmp_allocation);
+  if (!container->children && tmp_allocation.x == allocation->x &&
+      tmp_allocation.y == allocation->y &&
+      tmp_allocation.width == allocation->width &&
+      tmp_allocation.height == allocation->height) {
+    return;
+  }
+  gtk_widget_set_allocation(widget, allocation);
+
+  if (gtk_widget_get_has_window(widget) && gtk_widget_get_realized(widget)) {
+    gdk_window_move_resize(gtk_widget_get_window(widget), allocation->x,
+                           allocation->y, allocation->width,
+                           allocation->height);
+    // We need to position our subsurface according to GdkWindow
+    // when offset changes (GdkWindow is maximized for instance).
+    // see gtk-clutter-embed.c for reference.
+    MutexAutoLock lock(*container->wl_container.container_lock);
+    if (!container->wl_container.surface) {
+      if (!moz_container_wayland_surface_create_locked(lock, container)) {
+        return;
+      }
+    }
+    moz_container_wayland_set_scale_factor_locked(lock, container);
+    moz_container_wayland_set_opaque_region_locked(lock, container);
+    moz_container_wayland_move_locked(lock, container, allocation->x,
+                                      allocation->y);
+    moz_container_clear_input_region(container);
+    moz_container_wayland_invalidate(MOZ_CONTAINER(widget));
+    container->wl_container.before_first_size_alloc = false;
+  }
+}
+
+static wl_region* moz_container_wayland_create_opaque_region(
+    int aX, int aY, int aWidth, int aHeight, int aCornerRadius) {
+  struct wl_compositor* compositor = WaylandDisplayGet()->GetCompositor();
+  wl_region* region = wl_compositor_create_region(compositor);
+  wl_region_add(region, aX, aY, aWidth, aHeight);
+  if (aCornerRadius) {
+    wl_region_subtract(region, aX, aY, aCornerRadius, aCornerRadius);
+    wl_region_subtract(region, aX + aWidth - aCornerRadius, aY, aCornerRadius,
+                       aCornerRadius);
+  }
+  return region;
+}
+
+static void moz_container_wayland_set_opaque_region_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container) {
+  MozContainerWayland* wl_container = &container->wl_container;
+
+  if (!wl_container->opaque_region_needs_updates) {
+    return;
+  }
+
+  if (!wl_container->opaque_region_used) {
+    wl_container->opaque_region_needs_updates = false;
+    return;
+  }
+
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(GTK_WIDGET(container), &allocation);
+
+  wl_region* region = moz_container_wayland_create_opaque_region(
+      0, 0, allocation.width, allocation.height,
+      wl_container->opaque_region_corner_radius);
+  wl_surface_set_opaque_region(wl_container->surface, region);
+  wl_region_destroy(region);
+  wl_container->opaque_region_needs_updates = false;
+}
+
+static void moz_container_wayland_set_opaque_region(MozContainer* container) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  MutexAutoLock lock(*wl_container->container_lock);
+  if (wl_container->surface) {
+    moz_container_wayland_set_opaque_region_locked(lock, container);
+  }
+}
+
+static void moz_container_wayland_surface_set_scale_locked(
+    const MutexAutoLock& aProofOfLock, MozContainerWayland* wl_container,
+    int scale) {
+  if (wl_container->buffer_scale == scale) {
+    return;
+  }
+
+  LOGCONTAINER("%s scale %d\n", __FUNCTION__, scale);
+
+  // There is a chance that the attached wl_buffer has not yet been doubled
+  // on the main thread when scale factor changed to 2. This leads to
+  // crash with the following message:
+  // Buffer size (AxB) must be an integer multiple of the buffer_scale (2)
+  // Removing the possibly wrong wl_buffer to prevent that crash:
+  wl_surface_attach(wl_container->surface, nullptr, 0, 0);
+  wl_surface_set_buffer_scale(wl_container->surface, scale);
+  wl_container->buffer_scale = scale;
+}
+
+void moz_container_wayland_set_scale_factor_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container) {
+  if (gfx::gfxVars::UseWebRenderCompositor()) {
+    // the compositor backend handles scaling itself
+    return;
+  }
+
+  MozContainerWayland* wl_container = &container->wl_container;
+  wl_container->container_lock->AssertCurrentThreadOwns();
+
+  nsWindow* window = moz_container_get_nsWindow(container);
+  MOZ_DIAGNOSTIC_ASSERT(window);
+  if (window->UseFractionalScale()) {
+    if (!wl_container->viewport) {
+      wl_container->viewport = wp_viewporter_get_viewport(
+          WaylandDisplayGet()->GetViewporter(), wl_container->surface);
+    }
+
+    GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(container));
+    wp_viewport_set_destination(wl_container->viewport,
+                                gdk_window_get_width(gdkWindow),
+                                gdk_window_get_height(gdkWindow));
+  } else {
+    moz_container_wayland_surface_set_scale_locked(
+        aProofOfLock, wl_container, window->GdkCeiledScaleFactor());
+  }
+}
+
+void moz_container_wayland_set_scale_factor(MozContainer* container) {
+  MutexAutoLock lock(*container->wl_container.container_lock);
+  if (container->wl_container.surface) {
+    moz_container_wayland_set_scale_factor_locked(lock, container);
+  }
+}
+
+static bool moz_container_wayland_surface_create_locked(
+    const MutexAutoLock& aProofOfLock, MozContainer* container) {
+  MozContainerWayland* wl_container = &container->wl_container;
+
+  LOGWAYLAND("%s [%p]\n", __FUNCTION__,
+             (void*)moz_container_get_nsWindow(container));
+
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
+  MOZ_DIAGNOSTIC_ASSERT(window);
+
+  wl_surface* parent_surface = gdk_wayland_window_get_wl_surface(window);
+  if (!parent_surface) {
+    LOGWAYLAND("    Failed - missing parent surface!");
+    return false;
+  }
+  LOGWAYLAND("    gtk wl_surface %p ID %d\n", (void*)parent_surface,
+             wl_proxy_get_id((struct wl_proxy*)parent_surface));
+
+  if (wl_container->commit_to_parent) {
+    LOGWAYLAND("    commit to parent");
+    wl_container->surface = parent_surface;
+    NS_DispatchToCurrentThread(NewRunnableFunction(
+        "moz_container_wayland_frame_callback_handler",
+        &moz_container_wayland_frame_callback_handler, container, nullptr, 0));
+    return true;
+  }
+
+  // Available as of GTK 3.8+
+  struct wl_compositor* compositor = WaylandDisplayGet()->GetCompositor();
+  wl_container->surface = wl_compositor_create_surface(compositor);
+  if (!wl_container->surface) {
+    LOGWAYLAND("    Failed - can't create surface!");
+    return false;
+  }
+
+  wl_container->subsurface =
+      wl_subcompositor_get_subsurface(WaylandDisplayGet()->GetSubcompositor(),
+                                      wl_container->surface, parent_surface);
+  if (!wl_container->subsurface) {
+    MozClearPointer(wl_container->surface, wl_surface_destroy);
+    LOGWAYLAND("    Failed - can't create sub-surface!");
+    return false;
+  }
+  wl_subsurface_set_desync(wl_container->subsurface);
+
+  // Try to guess subsurface offset to avoid potential flickering.
+  int dx, dy;
+  if (moz_container_get_nsWindow(container)->GetCSDDecorationOffset(&dx, &dy)) {
+    wl_container->subsurface_dx = dx;
+    wl_container->subsurface_dy = dy;
+    wl_subsurface_set_position(wl_container->subsurface, dx, dy);
+    LOGWAYLAND("    guessing subsurface position %d %d\n", dx, dy);
+  }
+
+  // If there's pending frame callback it's for wrong parent surface,
+  // so delete it.
+  if (wl_container->frame_callback_handler) {
+    MozClearPointer(wl_container->frame_callback_handler, wl_callback_destroy);
+  }
+  wl_container->frame_callback_handler = wl_surface_frame(parent_surface);
+  wl_callback_add_listener(wl_container->frame_callback_handler,
+                           &moz_container_frame_listener, container);
+  LOGWAYLAND(
+      "    created frame callback ID %d\n",
+      wl_proxy_get_id((struct wl_proxy*)wl_container->frame_callback_handler));
+
+  wl_surface_commit(wl_container->surface);
+  wl_display_flush(WaylandDisplayGet()->GetDisplay());
+
+  wl_container->opaque_region_used =
+      moz_gdk_wayland_window_add_frame_callback_surface_locked(aProofOfLock,
+                                                               container);
+
+  LOGWAYLAND("    created surface %p ID %d\n", (void*)wl_container->surface,
+             wl_proxy_get_id((struct wl_proxy*)wl_container->surface));
+  return true;
+}
+
+struct wl_surface* moz_container_wayland_surface_lock(MozContainer* container)
+    MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  // LOGWAYLAND("%s [%p] surface %p ready_to_draw %d\n", __FUNCTION__,
+  //           (void*)container, (void*)container->wl_container.surface,
+  //           container->wl_container.ready_to_draw);
+  container->wl_container.container_lock->Lock();
+  if (!container->wl_container.surface ||
+      !container->wl_container.ready_to_draw) {
+    return nullptr;
+  }
+  return container->wl_container.surface;
+}
+
+void moz_container_wayland_surface_unlock(MozContainer* container,
+                                          struct wl_surface** surface)
+    MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  // Temporarily disabled to avoid log noise
+  // LOGWAYLAND("%s [%p] surface %p\n", __FUNCTION__, (void*)container,
+  //            (void*)container->wl_container.surface);
+  if (*surface) {
+    *surface = nullptr;
+  }
+  container->wl_container.container_lock->Unlock();
+}
+
+bool moz_container_wayland_egl_window_needs_size_update(MozContainer* container,
+                                                        nsIntSize aSize,
+                                                        int aScale) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  if (!wl_container->eglwindow) {
+    return false;
+  }
+  if (wl_container->buffer_scale != aScale) {
+    return true;
+  }
+  nsIntSize recentSize;
+  wl_egl_window_get_attached_size(wl_container->eglwindow, &recentSize.width,
+                                  &recentSize.height);
+  return aSize != recentSize;
+}
+
+struct wl_egl_window* moz_container_wayland_get_egl_window(
+    MozContainer* container, double scale) {
+  MozContainerWayland* wl_container = &container->wl_container;
+
+  LOGCONTAINER("%s [%p] eglwindow %p scale %d\n", __FUNCTION__,
+               (void*)moz_container_get_nsWindow(container),
+               (void*)wl_container->eglwindow, (int)scale);
+
+  MutexAutoLock lock(*wl_container->container_lock);
+  if (!wl_container->surface || !wl_container->ready_to_draw) {
+    LOGCONTAINER(
+        "  quit, wl_container->surface %p wl_container->ready_to_draw %d\n",
+        wl_container->surface, wl_container->ready_to_draw);
+    return nullptr;
+  }
+
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
+  nsIntSize requestedSize((int)round(gdk_window_get_width(window) * scale),
+                          (int)round(gdk_window_get_height(window) * scale));
+
+  if (!wl_container->eglwindow) {
+    wl_container->eglwindow = wl_egl_window_create(
+        wl_container->surface, requestedSize.width, requestedSize.height);
+
+    LOGCONTAINER("%s [%p] created eglwindow %p size %d x %d (with scale %f)\n",
+                 __FUNCTION__, (void*)moz_container_get_nsWindow(container),
+                 (void*)wl_container->eglwindow, requestedSize.width,
+                 requestedSize.height, scale);
+  } else {
+    nsIntSize recentSize;
+    wl_egl_window_get_attached_size(wl_container->eglwindow, &recentSize.width,
+                                    &recentSize.height);
+    if (requestedSize != recentSize) {
+      LOGCONTAINER("%s [%p] resized to %d x %d (with scale %f)\n", __FUNCTION__,
+                   (void*)moz_container_get_nsWindow(container),
+                   requestedSize.width, requestedSize.height, scale);
+      wl_egl_window_resize(wl_container->eglwindow, requestedSize.width,
+                           requestedSize.height, 0, 0);
+    }
+  }
+  moz_container_wayland_surface_set_scale_locked(lock, wl_container,
+                                                 static_cast<int>(scale));
+  return wl_container->eglwindow;
+}
+
+gboolean moz_container_wayland_has_egl_window(MozContainer* container) {
+  return container->wl_container.eglwindow != nullptr;
+}
+
+void moz_container_wayland_update_opaque_region(MozContainer* container,
+                                                int corner_radius) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  wl_container->opaque_region_needs_updates = true;
+  wl_container->opaque_region_corner_radius = corner_radius;
+
+  // When GL compositor / WebRender is used,
+  // moz_container_wayland_get_egl_window() is called only once when window
+  // is created or resized so update opaque region now.
+  if (moz_container_wayland_has_egl_window(container)) {
+    moz_container_wayland_set_opaque_region(container);
+  }
+}
+
+gboolean moz_container_wayland_can_draw(MozContainer* container) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  MutexAutoLock lock(*wl_container->container_lock);
+  return wl_container->ready_to_draw;
+}
+
+double moz_container_wayland_get_scale(MozContainer* container) {
+  nsWindow* window = moz_container_get_nsWindow(container);
+  return window ? window->FractionalScaleFactor() : 1;
+}
+
+void moz_container_wayland_set_commit_to_parent(MozContainer* container) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  MOZ_DIAGNOSTIC_ASSERT(!wl_container->surface);
+  wl_container->commit_to_parent = true;
+}
+
+bool moz_container_wayland_is_commiting_to_parent(MozContainer* container) {
+  MozContainerWayland* wl_container = &container->wl_container;
+  return wl_container->commit_to_parent;
+}
+
+bool moz_container_wayland_is_waiting_to_show(MozContainer* container) {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+  return container->wl_container.waiting_to_show;
+}
+
+void moz_container_wayland_clear_waiting_to_show_flag(MozContainer* container) {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+  container->wl_container.waiting_to_show = false;
+}
diff --git a/widget/gtk/MozContainerWayland.h b/widget/gtk/MozContainerWayland.h
new file mode 100644
index 0000000000..d3c49baae8
--- /dev/null
+++ b/widget/gtk/MozContainerWayland.h
@@ -0,0 +1,105 @@
+/* -*- 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_CONTAINER_WAYLAND_H__
+#define __MOZ_CONTAINER_WAYLAND_H__
+
+#include <gtk/gtk.h>
+#include <functional>
+#include <vector>
+#include "mozilla/Mutex.h"
+#include "WindowSurface.h"
+
+/*
+ * MozContainer
+ *
+ * This class serves three purposes in the nsIWidget implementation.
+ *
+ *   - It provides objects to receive signals from GTK for events on native
+ *     windows.
+ *
+ *   - It provides GdkWindow to draw content on Wayland or when Gtk+ renders
+ *     client side decorations to mShell.
+ */
+
+/* Workaround for bug at wayland-util.h,
+ * present in wayland-devel < 1.12
+ */
+struct wl_surface;
+struct wl_subsurface;
+
+struct MozContainerWayland {
+  struct wl_surface* surface;
+  struct wl_subsurface* subsurface;
+  int subsurface_dx, subsurface_dy;
+  struct wl_egl_window* eglwindow;
+  struct wl_callback* frame_callback_handler;
+  struct wp_viewport* viewport;
+  gboolean opaque_region_needs_updates;
+  int opaque_region_corner_radius;
+  gboolean opaque_region_used;
+  gboolean ready_to_draw;
+  gboolean commit_to_parent;
+  gboolean before_first_size_alloc;
+  gboolean waiting_to_show;
+  int buffer_scale;
+  std::vector<std::function<void(void)>> initial_draw_cbs;
+  // mozcontainer is used from Compositor and Rendering threads
+  // so we need to control access to mozcontainer where wayland internals
+  // are used directly.
+  mozilla::Mutex* container_lock;
+};
+
+struct _MozContainer;
+struct _MozContainerClass;
+typedef struct _MozContainer MozContainer;
+typedef struct _MozContainerClass MozContainerClass;
+
+class MozContainerSurfaceLock {
+  MozContainer* mContainer;
+  struct wl_surface* mSurface;
+
+ public:
+  explicit MozContainerSurfaceLock(MozContainer* aContainer);
+  ~MozContainerSurfaceLock();
+  struct wl_surface* GetSurface();
+};
+
+void moz_container_wayland_class_init(MozContainerClass* klass);
+void moz_container_wayland_init(MozContainerWayland* container);
+void moz_container_wayland_unmap(GtkWidget* widget);
+
+struct wl_egl_window* moz_container_wayland_get_egl_window(
+    MozContainer* container, double scale);
+
+gboolean moz_container_wayland_has_egl_window(MozContainer* container);
+void moz_container_wayland_egl_window_set_size(MozContainer* container,
+                                               nsIntSize aSize);
+bool moz_container_wayland_egl_window_needs_size_update(MozContainer* container,
+                                                        nsIntSize aSize,
+                                                        int scale);
+void moz_container_wayland_set_scale_factor(MozContainer* container);
+void moz_container_wayland_set_scale_factor_locked(
+    const mozilla::MutexAutoLock& aProofOfLock, MozContainer* container);
+
+void moz_container_wayland_add_initial_draw_callback_locked(
+    MozContainer* container, const std::function<void(void)>& initial_draw_cb);
+void moz_container_wayland_add_or_fire_initial_draw_callback(
+    MozContainer* container, const std::function<void(void)>& initial_draw_cb);
+void moz_container_wayland_clear_initial_draw_callback(MozContainer* container);
+
+wl_surface* moz_gtk_widget_get_wl_surface(GtkWidget* aWidget);
+void moz_container_wayland_update_opaque_region(MozContainer* container,
+                                                int corner_radius);
+gboolean moz_container_wayland_can_draw(MozContainer* container);
+double moz_container_wayland_get_scale(MozContainer* container);
+void moz_container_wayland_set_commit_to_parent(MozContainer* container);
+bool moz_container_wayland_is_commiting_to_parent(MozContainer* container);
+bool moz_container_wayland_is_waiting_to_show(MozContainer* container);
+void moz_container_wayland_clear_waiting_to_show_flag(MozContainer* container);
+
+#endif /* __MOZ_CONTAINER_WAYLAND_H__ */
diff --git a/widget/gtk/NativeKeyBindings.cpp b/widget/gtk/NativeKeyBindings.cpp
new file mode 100644
index 0000000000..f5b15367a6
--- /dev/null
+++ b/widget/gtk/NativeKeyBindings.cpp
@@ -0,0 +1,527 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/NativeKeyBindingsType.h"
+#include "mozilla/StaticPrefs_ui.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/WritingModes.h"
+
+#include "NativeKeyBindings.h"
+#include "nsString.h"
+#include "nsGtkKeyUtils.h"
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkkeysyms-compat.h>
+#include <gdk/gdk.h>
+
+namespace mozilla {
+namespace widget {
+
+static nsTArray<CommandInt>* gCurrentCommands = nullptr;
+static bool gHandled = false;
+
+inline void AddCommand(Command aCommand) {
+  MOZ_ASSERT(gCurrentCommands);
+  gCurrentCommands->AppendElement(static_cast<CommandInt>(aCommand));
+}
+
+// Common GtkEntry and GtkTextView signals
+static void copy_clipboard_cb(GtkWidget* w, gpointer user_data) {
+  AddCommand(Command::Copy);
+  g_signal_stop_emission_by_name(w, "copy_clipboard");
+  gHandled = true;
+}
+
+static void cut_clipboard_cb(GtkWidget* w, gpointer user_data) {
+  AddCommand(Command::Cut);
+  g_signal_stop_emission_by_name(w, "cut_clipboard");
+  gHandled = true;
+}
+
+// GTK distinguishes between display lines (wrapped, as they appear on the
+// screen) and paragraphs, which are runs of text terminated by a newline.
+// We don't have this distinction, so we always use editor's notion of
+// lines, which are newline-terminated.
+
+static const Command sDeleteCommands[][2] = {
+    // backward, forward
+    // CHARS
+    {Command::DeleteCharBackward, Command::DeleteCharForward},
+    // WORD_ENDS
+    {Command::DeleteWordBackward, Command::DeleteWordForward},
+    // WORDS
+    {Command::DeleteWordBackward, Command::DeleteWordForward},
+    // LINES
+    {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine},
+    // LINE_ENDS
+    {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine},
+    // PARAGRAPH_ENDS
+    {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine},
+    // PARAGRAPHS
+    {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine},
+    // This deletes from the end of the previous word to the beginning of the
+    // next word, but only if the caret is not in a word.
+    // XXX need to implement in editor
+    {Command::DoNothing, Command::DoNothing}  // WHITESPACE
+};
+
+static void delete_from_cursor_cb(GtkWidget* w, GtkDeleteType del_type,
+                                  gint count, gpointer user_data) {
+  g_signal_stop_emission_by_name(w, "delete_from_cursor");
+  if (count == 0) {
+    // Nothing to do.
+    return;
+  }
+
+  bool forward = count > 0;
+
+  // Ignore GTK's Ctrl-K keybinding introduced in GTK 3.14 and removed in
+  // 3.18 if the user has custom bindings set. See bug 1176929.
+  if (del_type == GTK_DELETE_PARAGRAPH_ENDS && forward && GTK_IS_ENTRY(w) &&
+      !gtk_check_version(3, 14, 1) && gtk_check_version(3, 17, 9)) {
+    GtkStyleContext* context = gtk_widget_get_style_context(w);
+    GtkStateFlags flags = gtk_widget_get_state_flags(w);
+
+    GPtrArray* array;
+    gtk_style_context_get(context, flags, "gtk-key-bindings", &array, nullptr);
+    if (!array) return;
+    g_ptr_array_unref(array);
+  }
+
+  gHandled = true;
+  if (uint32_t(del_type) >= ArrayLength(sDeleteCommands)) {
+    // unsupported deletion type
+    return;
+  }
+
+  if (del_type == GTK_DELETE_WORDS) {
+    // This works like word_ends, except we first move the caret to the
+    // beginning/end of the current word.
+    if (forward) {
+      AddCommand(Command::WordNext);
+      AddCommand(Command::WordPrevious);
+    } else {
+      AddCommand(Command::WordPrevious);
+      AddCommand(Command::WordNext);
+    }
+  } else if (del_type == GTK_DELETE_DISPLAY_LINES ||
+             del_type == GTK_DELETE_PARAGRAPHS) {
+    // This works like display_line_ends, except we first move the caret to the
+    // beginning/end of the current line.
+    if (forward) {
+      AddCommand(Command::BeginLine);
+    } else {
+      AddCommand(Command::EndLine);
+    }
+  }
+
+  Command command = sDeleteCommands[del_type][forward];
+  if (command == Command::DoNothing) {
+    return;
+  }
+
+  unsigned int absCount = Abs(count);
+  for (unsigned int i = 0; i < absCount; ++i) {
+    AddCommand(command);
+  }
+}
+
+static const Command sMoveCommands[][2][2] = {
+    // non-extend { backward, forward }, extend { backward, forward }
+    // GTK differentiates between logical position, which is prev/next,
+    // and visual position, which is always left/right.
+    // We should fix this to work the same way for RTL text input.
+    {// LOGICAL_POSITIONS
+     {Command::CharPrevious, Command::CharNext},
+     {Command::SelectCharPrevious, Command::SelectCharNext}},
+    {// VISUAL_POSITIONS
+     {Command::CharPrevious, Command::CharNext},
+     {Command::SelectCharPrevious, Command::SelectCharNext}},
+    {// WORDS
+     {Command::WordPrevious, Command::WordNext},
+     {Command::SelectWordPrevious, Command::SelectWordNext}},
+    {// DISPLAY_LINES
+     {Command::LinePrevious, Command::LineNext},
+     {Command::SelectLinePrevious, Command::SelectLineNext}},
+    {// DISPLAY_LINE_ENDS
+     {Command::BeginLine, Command::EndLine},
+     {Command::SelectBeginLine, Command::SelectEndLine}},
+    {// PARAGRAPHS
+     {Command::LinePrevious, Command::LineNext},
+     {Command::SelectLinePrevious, Command::SelectLineNext}},
+    {// PARAGRAPH_ENDS
+     {Command::BeginLine, Command::EndLine},
+     {Command::SelectBeginLine, Command::SelectEndLine}},
+    {// PAGES
+     {Command::MovePageUp, Command::MovePageDown},
+     {Command::SelectPageUp, Command::SelectPageDown}},
+    {// BUFFER_ENDS
+     {Command::MoveTop, Command::MoveBottom},
+     {Command::SelectTop, Command::SelectBottom}},
+    {// HORIZONTAL_PAGES (unsupported)
+     {Command::DoNothing, Command::DoNothing},
+     {Command::DoNothing, Command::DoNothing}}};
+
+static void move_cursor_cb(GtkWidget* w, GtkMovementStep step, gint count,
+                           gboolean extend_selection, gpointer user_data) {
+  g_signal_stop_emission_by_name(w, "move_cursor");
+  if (count == 0) {
+    // Nothing to do.
+    return;
+  }
+
+  gHandled = true;
+  bool forward = count > 0;
+  if (uint32_t(step) >= ArrayLength(sMoveCommands)) {
+    // unsupported movement type
+    return;
+  }
+
+  Command command = sMoveCommands[step][extend_selection][forward];
+  if (command == Command::DoNothing) {
+    return;
+  }
+
+  unsigned int absCount = Abs(count);
+  for (unsigned int i = 0; i < absCount; ++i) {
+    AddCommand(command);
+  }
+}
+
+static void paste_clipboard_cb(GtkWidget* w, gpointer user_data) {
+  AddCommand(Command::Paste);
+  g_signal_stop_emission_by_name(w, "paste_clipboard");
+  gHandled = true;
+}
+
+// GtkTextView-only signals
+static void select_all_cb(GtkWidget* aWidget, gboolean aSelect,
+                          gpointer aUserData) {
+  // We don't support "Unselect All" command.
+  // Note that if we'd support it, `Ctrl-Shift-a` will be mapped to it and
+  // overrides open `about:addons` shortcut.
+  if (aSelect) {
+    AddCommand(Command::SelectAll);
+  }
+  g_signal_stop_emission_by_name(aWidget, "select_all");
+  // Although we prevent the default of `GtkTExtView` with
+  // `g_signal_stop_emission_by_name`, but `gHandled` is used for asserting
+  // if it does not match with the emptiness of the command array.
+  // Therefore, we should not set it to `true` if we don't add a command.
+  gHandled |= aSelect;
+}
+
+NativeKeyBindings* NativeKeyBindings::sInstanceForSingleLineEditor = nullptr;
+NativeKeyBindings* NativeKeyBindings::sInstanceForMultiLineEditor = nullptr;
+
+// static
+NativeKeyBindings* NativeKeyBindings::GetInstance(NativeKeyBindingsType aType) {
+  switch (aType) {
+    case NativeKeyBindingsType::SingleLineEditor:
+      if (!sInstanceForSingleLineEditor) {
+        sInstanceForSingleLineEditor = new NativeKeyBindings();
+        sInstanceForSingleLineEditor->Init(aType);
+      }
+      return sInstanceForSingleLineEditor;
+
+    default:
+      // fallback to multiline editor case in release build
+      MOZ_FALLTHROUGH_ASSERT("aType is invalid or not yet implemented");
+    case NativeKeyBindingsType::MultiLineEditor:
+    case NativeKeyBindingsType::RichTextEditor:
+      if (!sInstanceForMultiLineEditor) {
+        sInstanceForMultiLineEditor = new NativeKeyBindings();
+        sInstanceForMultiLineEditor->Init(aType);
+      }
+      return sInstanceForMultiLineEditor;
+  }
+}
+
+// static
+void NativeKeyBindings::Shutdown() {
+  delete sInstanceForSingleLineEditor;
+  sInstanceForSingleLineEditor = nullptr;
+  delete sInstanceForMultiLineEditor;
+  sInstanceForMultiLineEditor = nullptr;
+}
+
+void NativeKeyBindings::Init(NativeKeyBindingsType aType) {
+  switch (aType) {
+    case NativeKeyBindingsType::SingleLineEditor:
+      mNativeTarget = gtk_entry_new();
+      break;
+    default:
+      mNativeTarget = gtk_text_view_new();
+      g_signal_connect(mNativeTarget, "select_all", G_CALLBACK(select_all_cb),
+                       this);
+      break;
+  }
+
+  g_object_ref_sink(mNativeTarget);
+
+  g_signal_connect(mNativeTarget, "copy_clipboard",
+                   G_CALLBACK(copy_clipboard_cb), this);
+  g_signal_connect(mNativeTarget, "cut_clipboard", G_CALLBACK(cut_clipboard_cb),
+                   this);
+  g_signal_connect(mNativeTarget, "delete_from_cursor",
+                   G_CALLBACK(delete_from_cursor_cb), this);
+  g_signal_connect(mNativeTarget, "move_cursor", G_CALLBACK(move_cursor_cb),
+                   this);
+  g_signal_connect(mNativeTarget, "paste_clipboard",
+                   G_CALLBACK(paste_clipboard_cb), this);
+}
+
+NativeKeyBindings::~NativeKeyBindings() {
+  gtk_widget_destroy(mNativeTarget);
+  g_object_unref(mNativeTarget);
+}
+
+void NativeKeyBindings::GetEditCommands(const WidgetKeyboardEvent& aEvent,
+                                        const Maybe<WritingMode>& aWritingMode,
+                                        nsTArray<CommandInt>& aCommands) {
+  MOZ_ASSERT(!aEvent.mFlags.mIsSynthesizedForTests);
+  MOZ_ASSERT(aCommands.IsEmpty());
+
+  // It must be a DOM event dispached by chrome script.
+  if (!aEvent.mNativeKeyEvent) {
+    return;
+  }
+
+  guint keyval;
+  if (aEvent.mCharCode) {
+    keyval = gdk_unicode_to_keyval(aEvent.mCharCode);
+  } else if (aWritingMode.isSome() && aEvent.NeedsToRemapNavigationKey() &&
+             aWritingMode.ref().IsVertical()) {
+    // TODO: Use KeyNameIndex rather than legacy keyCode.
+    uint32_t remappedGeckoKeyCode =
+        aEvent.GetRemappedKeyCode(aWritingMode.ref());
+    switch (remappedGeckoKeyCode) {
+      case NS_VK_UP:
+        keyval = GDK_Up;
+        break;
+      case NS_VK_DOWN:
+        keyval = GDK_Down;
+        break;
+      case NS_VK_LEFT:
+        keyval = GDK_Left;
+        break;
+      case NS_VK_RIGHT:
+        keyval = GDK_Right;
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE("Add a case for the new remapped key");
+        return;
+    }
+  } else {
+    keyval = static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->keyval;
+  }
+
+  if (GetEditCommandsInternal(aEvent, aCommands, keyval)) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < aEvent.mAlternativeCharCodes.Length(); ++i) {
+    uint32_t ch = aEvent.IsShift()
+                      ? aEvent.mAlternativeCharCodes[i].mShiftedCharCode
+                      : aEvent.mAlternativeCharCodes[i].mUnshiftedCharCode;
+    if (ch && ch != aEvent.mCharCode) {
+      keyval = gdk_unicode_to_keyval(ch);
+      if (GetEditCommandsInternal(aEvent, aCommands, keyval)) {
+        return;
+      }
+    }
+  }
+
+  // If the key event does not cause any commands, and we're for single line
+  // editor, let's check whether the key combination is for "select-all" in
+  // GtkTextView because the signal is not supported by GtkEntry.
+  if (aCommands.IsEmpty() && this == sInstanceForSingleLineEditor &&
+      StaticPrefs::ui_key_use_select_all_in_single_line_editor()) {
+    if (NativeKeyBindings* bindingsForMultilineEditor =
+            GetInstance(NativeKeyBindingsType::MultiLineEditor)) {
+      bindingsForMultilineEditor->GetEditCommands(aEvent, aWritingMode,
+                                                  aCommands);
+      if (aCommands.Length() == 1u &&
+          aCommands[0u] == static_cast<CommandInt>(Command::SelectAll)) {
+        return;
+      }
+      aCommands.Clear();
+    }
+  }
+
+  /*
+  gtk_bindings_activate_event is preferable, but it has unresolved bug:
+  http://bugzilla.gnome.org/show_bug.cgi?id=162726
+  The bug was already marked as FIXED.  However, somebody reports that the
+  bug still exists.
+  Also gtk_bindings_activate may work with some non-shortcuts operations
+  (todo: check it). See bug 411005 and bug 406407.
+
+  Code, which should be used after fixing GNOME bug 162726:
+
+    gtk_bindings_activate_event(GTK_OBJECT(mNativeTarget),
+      static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent));
+  */
+}
+
+bool NativeKeyBindings::GetEditCommandsInternal(
+    const WidgetKeyboardEvent& aEvent, nsTArray<CommandInt>& aCommands,
+    guint aKeyval) {
+  guint modifiers = static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->state;
+
+  gCurrentCommands = &aCommands;
+
+  gHandled = false;
+  gtk_bindings_activate(G_OBJECT(mNativeTarget), aKeyval,
+                        GdkModifierType(modifiers));
+
+  gCurrentCommands = nullptr;
+
+  return gHandled;
+}
+
+// static
+void NativeKeyBindings::GetEditCommandsForTests(
+    NativeKeyBindingsType aType, const WidgetKeyboardEvent& aEvent,
+    const Maybe<WritingMode>& aWritingMode, nsTArray<CommandInt>& aCommands) {
+  MOZ_DIAGNOSTIC_ASSERT(aEvent.IsTrusted());
+
+  if (aEvent.IsAlt() || aEvent.IsMeta() || aEvent.IsOS()) {
+    return;
+  }
+
+  static const size_t kBackward = 0;
+  static const size_t kForward = 1;
+  const size_t extentSelection = aEvent.IsShift() ? 1 : 0;
+  // https://github.com/GNOME/gtk/blob/1f141c19533f4b3f397c3959ade673ce243b6138/gtk/gtktext.c#L1289
+  // https://github.com/GNOME/gtk/blob/c5dd34344f0c660ceffffb3bf9da43c263db16e1/gtk/gtktextview.c#L1534
+  Command command = Command::DoNothing;
+  const KeyNameIndex remappedKeyNameIndex =
+      aWritingMode.isSome() ? aEvent.GetRemappedKeyNameIndex(aWritingMode.ref())
+                            : aEvent.mKeyNameIndex;
+  switch (remappedKeyNameIndex) {
+    case KEY_NAME_INDEX_USE_STRING:
+      switch (aEvent.PseudoCharCode()) {
+        case 'a':
+        case 'A':
+          if (aEvent.IsControl()) {
+            command = Command::SelectAll;
+          }
+          break;
+        case 'c':
+        case 'C':
+          if (aEvent.IsControl() && !aEvent.IsShift()) {
+            command = Command::Copy;
+          }
+          break;
+        case 'u':
+        case 'U':
+          if (aType == NativeKeyBindingsType::SingleLineEditor &&
+              aEvent.IsControl() && !aEvent.IsShift()) {
+            command = sDeleteCommands[GTK_DELETE_PARAGRAPH_ENDS][kBackward];
+          }
+          break;
+        case 'v':
+        case 'V':
+          if (aEvent.IsControl() && !aEvent.IsShift()) {
+            command = Command::Paste;
+          }
+          break;
+        case 'x':
+        case 'X':
+          if (aEvent.IsControl() && !aEvent.IsShift()) {
+            command = Command::Cut;
+          }
+          break;
+        case '/':
+          if (aEvent.IsControl() && !aEvent.IsShift()) {
+            command = Command::SelectAll;
+          }
+          break;
+        default:
+          break;
+      }
+      break;
+    case KEY_NAME_INDEX_Insert:
+      if (aEvent.IsControl() && !aEvent.IsShift()) {
+        command = Command::Copy;
+      } else if (aEvent.IsShift() && !aEvent.IsControl()) {
+        command = Command::Paste;
+      }
+      break;
+    case KEY_NAME_INDEX_Delete:
+      if (aEvent.IsShift()) {
+        command = Command::Cut;
+        break;
+      }
+      [[fallthrough]];
+    case KEY_NAME_INDEX_Backspace: {
+      const size_t direction =
+          remappedKeyNameIndex == KEY_NAME_INDEX_Delete ? kForward : kBackward;
+      const GtkDeleteType amount =
+          aEvent.IsControl() && aEvent.IsShift()
+              ? GTK_DELETE_PARAGRAPH_ENDS
+              // FYI: Shift key for Backspace is ignored to help mis-typing.
+              : (aEvent.IsControl() ? GTK_DELETE_WORD_ENDS : GTK_DELETE_CHARS);
+      command = sDeleteCommands[amount][direction];
+      break;
+    }
+    case KEY_NAME_INDEX_ArrowLeft:
+    case KEY_NAME_INDEX_ArrowRight: {
+      const size_t direction = remappedKeyNameIndex == KEY_NAME_INDEX_ArrowRight
+                                   ? kForward
+                                   : kBackward;
+      const GtkMovementStep amount = aEvent.IsControl()
+                                         ? GTK_MOVEMENT_WORDS
+                                         : GTK_MOVEMENT_VISUAL_POSITIONS;
+      command = sMoveCommands[amount][extentSelection][direction];
+      break;
+    }
+    case KEY_NAME_INDEX_ArrowUp:
+    case KEY_NAME_INDEX_ArrowDown: {
+      const size_t direction = remappedKeyNameIndex == KEY_NAME_INDEX_ArrowDown
+                                   ? kForward
+                                   : kBackward;
+      const GtkMovementStep amount = aEvent.IsControl()
+                                         ? GTK_MOVEMENT_PARAGRAPHS
+                                         : GTK_MOVEMENT_DISPLAY_LINES;
+      command = sMoveCommands[amount][extentSelection][direction];
+      break;
+    }
+    case KEY_NAME_INDEX_Home:
+    case KEY_NAME_INDEX_End: {
+      const size_t direction =
+          remappedKeyNameIndex == KEY_NAME_INDEX_End ? kForward : kBackward;
+      const GtkMovementStep amount = aEvent.IsControl()
+                                         ? GTK_MOVEMENT_BUFFER_ENDS
+                                         : GTK_MOVEMENT_DISPLAY_LINE_ENDS;
+      command = sMoveCommands[amount][extentSelection][direction];
+      break;
+    }
+    case KEY_NAME_INDEX_PageUp:
+    case KEY_NAME_INDEX_PageDown: {
+      const size_t direction = remappedKeyNameIndex == KEY_NAME_INDEX_PageDown
+                                   ? kForward
+                                   : kBackward;
+      const GtkMovementStep amount = aEvent.IsControl()
+                                         ? GTK_MOVEMENT_HORIZONTAL_PAGES
+                                         : GTK_MOVEMENT_PAGES;
+      command = sMoveCommands[amount][extentSelection][direction];
+      break;
+    }
+    default:
+      break;
+  }
+  if (command != Command::DoNothing) {
+    aCommands.AppendElement(static_cast<CommandInt>(command));
+  }
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/NativeKeyBindings.h b/widget/gtk/NativeKeyBindings.h
new file mode 100644
index 0000000000..1d0c528621
--- /dev/null
+++ b/widget/gtk/NativeKeyBindings.h
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef NativeKeyBindings_h
+#define NativeKeyBindings_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/EventForwards.h"
+#include "nsIWidget.h"
+
+#include <glib.h>  // for guint
+
+using GtkWidget = struct _GtkWidget;
+
+namespace mozilla {
+enum class NativeKeyBindingsType : uint8_t;
+
+class WritingMode;
+template <typename T>
+class Maybe;
+
+namespace widget {
+
+class NativeKeyBindings final {
+ public:
+  static NativeKeyBindings* GetInstance(NativeKeyBindingsType aType);
+  static void Shutdown();
+
+  /**
+   * GetEditCommandsForTests() returns commands performed in native widget
+   * in typical environment.  I.e., this does NOT refer customized shortcut
+   * key mappings of the environment.
+   */
+  static void GetEditCommandsForTests(NativeKeyBindingsType aType,
+                                      const WidgetKeyboardEvent& aEvent,
+                                      const Maybe<WritingMode>& aWritingMode,
+                                      nsTArray<CommandInt>& aCommands);
+
+  void Init(NativeKeyBindingsType aType);
+
+  void GetEditCommands(const WidgetKeyboardEvent& aEvent,
+                       const Maybe<WritingMode>& aWritingMode,
+                       nsTArray<CommandInt>& aCommands);
+
+ private:
+  ~NativeKeyBindings();
+
+  bool GetEditCommandsInternal(const WidgetKeyboardEvent& aEvent,
+                               nsTArray<CommandInt>& aCommands, guint aKeyval);
+
+  GtkWidget* mNativeTarget;
+
+  static NativeKeyBindings* sInstanceForSingleLineEditor;
+  static NativeKeyBindings* sInstanceForMultiLineEditor;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // NativeKeyBindings_h
diff --git a/widget/gtk/NativeMenuGtk.cpp b/widget/gtk/NativeMenuGtk.cpp
new file mode 100644
index 0000000000..7f2c5916fe
--- /dev/null
+++ b/widget/gtk/NativeMenuGtk.cpp
@@ -0,0 +1,423 @@
+/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- */
+/* 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 "NativeMenuGtk.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/XULCommandEvent.h"
+#include "mozilla/WidgetUtilsGtk.h"
+#include "mozilla/EventDispatcher.h"
+#include "nsPresContext.h"
+#include "nsIWidget.h"
+#include "nsWindow.h"
+#include "nsStubMutationObserver.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/StaticPrefs_widget.h"
+
+#include <dlfcn.h>
+#include <gtk/gtk.h>
+
+namespace mozilla::widget {
+
+using GtkMenuPopupAtRect = void (*)(GtkMenu* menu, GdkWindow* rect_window,
+                                    const GdkRectangle* rect,
+                                    GdkGravity rect_anchor,
+                                    GdkGravity menu_anchor,
+                                    const GdkEvent* trigger_event);
+
+static bool IsDisabled(const dom::Element& aElement) {
+  return aElement.AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                              nsGkAtoms::_true, eCaseMatters) ||
+         aElement.AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidden,
+                              nsGkAtoms::_true, eCaseMatters);
+}
+static bool NodeIsRelevant(const nsINode& aNode) {
+  return aNode.IsAnyOfXULElements(nsGkAtoms::menu, nsGkAtoms::menuseparator,
+                                  nsGkAtoms::menuitem, nsGkAtoms::menugroup);
+}
+
+// If this is a radio / checkbox menuitem, get the current value.
+static Maybe<bool> GetChecked(const dom::Element& aMenuItem) {
+  static dom::Element::AttrValuesArray strings[] = {nsGkAtoms::checkbox,
+                                                    nsGkAtoms::radio, nullptr};
+  switch (aMenuItem.FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::type, strings,
+                                    eCaseMatters)) {
+    case 0:
+      break;
+    case 1:
+      break;
+    default:
+      return Nothing();
+  }
+
+  return Some(aMenuItem.AttrValueIs(kNameSpaceID_None, nsGkAtoms::checked,
+                                    nsGkAtoms::_true, eCaseMatters));
+}
+
+struct Actions {
+  RefPtr<GSimpleActionGroup> mGroup;
+  size_t mNextActionIndex = 0;
+
+  nsPrintfCString Register(const dom::Element&, bool aForSubmenu);
+  void Clear();
+};
+
+static MOZ_CAN_RUN_SCRIPT void ActivateItem(dom::Element& aElement) {
+  if (Maybe<bool> checked = GetChecked(aElement)) {
+    if (!aElement.AttrValueIs(kNameSpaceID_None, nsGkAtoms::autocheck,
+                              nsGkAtoms::_false, eCaseMatters)) {
+      bool newValue = !*checked;
+      if (newValue) {
+        aElement.SetAttr(kNameSpaceID_None, nsGkAtoms::checked, u"true"_ns,
+                         true);
+      } else {
+        aElement.UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked, true);
+      }
+    }
+  }
+
+  RefPtr doc = aElement.OwnerDoc();
+  RefPtr event = new dom::XULCommandEvent(doc, doc->GetPresContext(), nullptr);
+  IgnoredErrorResult rv;
+  event->InitCommandEvent(u"command"_ns, true, true,
+                          nsGlobalWindowInner::Cast(doc->GetInnerWindow()), 0,
+                          /* ctrlKey = */ false, /* altKey = */ false,
+                          /* shiftKey = */ false, /* cmdKey = */ false,
+                          /* button = */ MouseButton::ePrimary, nullptr, 0, rv);
+  if (MOZ_UNLIKELY(rv.Failed())) {
+    return;
+  }
+  aElement.DispatchEvent(*event);
+}
+
+static MOZ_CAN_RUN_SCRIPT void ActivateSignal(GSimpleAction* aAction,
+                                              GVariant* aParam,
+                                              gpointer aUserData) {
+  RefPtr element = static_cast<dom::Element*>(aUserData);
+  ActivateItem(*element);
+}
+
+static MOZ_CAN_RUN_SCRIPT void FireEvent(dom::Element* aTarget,
+                                         EventMessage aPopupMessage) {
+  nsEventStatus status = nsEventStatus_eIgnore;
+  WidgetMouseEvent event(true, aPopupMessage, nullptr, WidgetMouseEvent::eReal);
+  EventDispatcher::Dispatch(aTarget, nullptr, &event, nullptr, &status);
+}
+
+static MOZ_CAN_RUN_SCRIPT void ChangeStateSignal(GSimpleAction* aAction,
+                                                 GVariant* aParam,
+                                                 gpointer aUserData) {
+  // TODO: Fire events when safe. These run at a bad time for now.
+  static constexpr bool kEnabled = false;
+  if (!kEnabled) {
+    return;
+  }
+  const bool open = g_variant_get_boolean(aParam);
+  RefPtr popup = static_cast<dom::Element*>(aUserData);
+  if (open) {
+    FireEvent(popup, eXULPopupShowing);
+    FireEvent(popup, eXULPopupShown);
+  } else {
+    FireEvent(popup, eXULPopupHiding);
+    FireEvent(popup, eXULPopupHidden);
+  }
+}
+
+nsPrintfCString Actions::Register(const dom::Element& aMenuItem,
+                                  bool aForSubmenu) {
+  nsPrintfCString actionName("item-%zu", mNextActionIndex++);
+  Maybe<bool> paramValue = aForSubmenu ? Some(false) : GetChecked(aMenuItem);
+  RefPtr<GSimpleAction> action;
+  if (paramValue) {
+    action = dont_AddRef(g_simple_action_new_stateful(
+        actionName.get(), nullptr, g_variant_new_boolean(*paramValue)));
+  } else {
+    action = dont_AddRef(g_simple_action_new(actionName.get(), nullptr));
+  }
+  if (aForSubmenu) {
+    g_signal_connect(action, "change-state", G_CALLBACK(ChangeStateSignal),
+                     gpointer(&aMenuItem));
+  } else {
+    g_signal_connect(action, "activate", G_CALLBACK(ActivateSignal),
+                     gpointer(&aMenuItem));
+  }
+  g_action_map_add_action(G_ACTION_MAP(mGroup.get()), G_ACTION(action.get()));
+  return actionName;
+}
+
+void Actions::Clear() {
+  for (size_t i = 0; i < mNextActionIndex; ++i) {
+    g_action_map_remove_action(G_ACTION_MAP(mGroup.get()),
+                               nsPrintfCString("item-%zu", i).get());
+  }
+  mNextActionIndex = 0;
+}
+
+class MenuModel final : public nsStubMutationObserver {
+  NS_DECL_ISUPPORTS
+
+  NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
+  NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
+  NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
+  NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
+
+ public:
+  explicit MenuModel(dom::Element* aElement) : mElement(aElement) {
+    mElement->AddMutationObserver(this);
+    mGMenu = dont_AddRef(g_menu_new());
+    mActions.mGroup = dont_AddRef(g_simple_action_group_new());
+  }
+
+  GMenuModel* GetModel() { return G_MENU_MODEL(mGMenu.get()); }
+  GActionGroup* GetActionGroup() {
+    return G_ACTION_GROUP(mActions.mGroup.get());
+  }
+
+  dom::Element* Element() { return mElement; }
+
+  void RecomputeModelIfNeeded();
+
+  bool IsShowing() { return mPoppedUp; }
+  void WillShow() {
+    mPoppedUp = true;
+    RecomputeModelIfNeeded();
+  }
+  void DidHide() { mPoppedUp = false; }
+
+ private:
+  virtual ~MenuModel() { mElement->RemoveMutationObserver(this); }
+
+  void DirtyModel() {
+    mDirty = true;
+    if (mPoppedUp) {
+      RecomputeModelIfNeeded();
+    }
+  }
+
+  RefPtr<dom::Element> mElement;
+  RefPtr<GMenu> mGMenu;
+  Actions mActions;
+  bool mDirty = true;
+  bool mPoppedUp = false;
+};
+
+NS_IMPL_ISUPPORTS(MenuModel, nsIMutationObserver)
+
+void MenuModel::ContentRemoved(nsIContent* aChild, nsIContent*) {
+  if (NodeIsRelevant(*aChild)) {
+    DirtyModel();
+  }
+}
+
+void MenuModel::ContentInserted(nsIContent* aChild) {
+  if (NodeIsRelevant(*aChild)) {
+    DirtyModel();
+  }
+}
+
+void MenuModel::ContentAppended(nsIContent* aChild) {
+  if (NodeIsRelevant(*aChild)) {
+    DirtyModel();
+  }
+}
+
+void MenuModel::AttributeChanged(dom::Element* aElement, int32_t aNameSpaceID,
+                                 nsAtom* aAttribute, int32_t aModType,
+                                 const nsAttrValue* aOldValue) {
+  if (NodeIsRelevant(*aElement) &&
+      (aAttribute == nsGkAtoms::label || aAttribute == nsGkAtoms::aria_label ||
+       aAttribute == nsGkAtoms::disabled || aAttribute == nsGkAtoms::hidden)) {
+    DirtyModel();
+  }
+}
+
+static const dom::Element* GetMenuPopupChild(const dom::Element& aElement) {
+  for (const nsIContent* child = aElement.GetFirstChild(); child;
+       child = child->GetNextSibling()) {
+    if (child->IsXULElement(nsGkAtoms::menupopup)) {
+      return child->AsElement();
+    }
+  }
+  return nullptr;
+}
+
+static void RecomputeModelFor(GMenu* aMenu, Actions& aActions,
+                              const dom::Element& aElement) {
+  RefPtr<GMenu> sectionMenu;
+  auto FlushSectionMenu = [&] {
+    if (sectionMenu) {
+      g_menu_append_section(aMenu, nullptr, G_MENU_MODEL(sectionMenu.get()));
+      sectionMenu = nullptr;
+    }
+  };
+
+  for (const nsIContent* child = aElement.GetFirstChild(); child;
+       child = child->GetNextSibling()) {
+    if (child->IsXULElement(nsGkAtoms::menuitem) &&
+        !IsDisabled(*child->AsElement())) {
+      nsAutoString label;
+      child->AsElement()->GetAttr(nsGkAtoms::label, label);
+      if (label.IsEmpty()) {
+        child->AsElement()->GetAttr(nsGkAtoms::aria_label, label);
+      }
+      nsPrintfCString actionName(
+          "menu.%s",
+          aActions.Register(*child->AsElement(), /* aForSubmenu = */ false)
+              .get());
+      g_menu_append(sectionMenu ? sectionMenu.get() : aMenu,
+                    NS_ConvertUTF16toUTF8(label).get(), actionName.get());
+      continue;
+    }
+    if (child->IsXULElement(nsGkAtoms::menuseparator)) {
+      FlushSectionMenu();
+      sectionMenu = dont_AddRef(g_menu_new());
+      continue;
+    }
+    if (child->IsXULElement(nsGkAtoms::menugroup)) {
+      FlushSectionMenu();
+      sectionMenu = dont_AddRef(g_menu_new());
+      RecomputeModelFor(sectionMenu, aActions, *child->AsElement());
+      FlushSectionMenu();
+      continue;
+    }
+    if (child->IsXULElement(nsGkAtoms::menu) &&
+        !IsDisabled(*child->AsElement())) {
+      if (const auto* popup = GetMenuPopupChild(*child->AsElement())) {
+        RefPtr<GMenu> submenu = dont_AddRef(g_menu_new());
+        RecomputeModelFor(submenu, aActions, *popup);
+        nsAutoString label;
+        child->AsElement()->GetAttr(nsGkAtoms::label, label);
+        RefPtr<GMenuItem> submenuItem = dont_AddRef(g_menu_item_new_submenu(
+            NS_ConvertUTF16toUTF8(label).get(), G_MENU_MODEL(submenu.get())));
+        nsPrintfCString actionName(
+            "menu.%s",
+            aActions.Register(*popup, /* aForSubmenu = */ true).get());
+        g_menu_item_set_attribute_value(submenuItem.get(), "submenu-action",
+                                        g_variant_new_string(actionName.get()));
+        g_menu_append_item(sectionMenu ? sectionMenu.get() : aMenu,
+                           submenuItem.get());
+      }
+    }
+  }
+
+  FlushSectionMenu();
+}
+
+void MenuModel::RecomputeModelIfNeeded() {
+  if (!mDirty) {
+    return;
+  }
+  mActions.Clear();
+  g_menu_remove_all(mGMenu.get());
+  RecomputeModelFor(mGMenu.get(), mActions, *mElement);
+}
+
+static GtkMenuPopupAtRect GetPopupAtRectFn() {
+  static GtkMenuPopupAtRect sFunc =
+      (GtkMenuPopupAtRect)dlsym(RTLD_DEFAULT, "gtk_menu_popup_at_rect");
+  return sFunc;
+}
+
+bool NativeMenuGtk::CanUse() {
+  return StaticPrefs::widget_gtk_native_context_menus() && GetPopupAtRectFn();
+}
+
+void NativeMenuGtk::FireEvent(EventMessage aPopupMessage) {
+  RefPtr target = Element();
+  widget::FireEvent(target, aPopupMessage);
+}
+
+#define METHOD_SIGNAL(name_)                                 \
+  static MOZ_CAN_RUN_SCRIPT_BOUNDARY void On##name_##Signal( \
+      GtkWidget* widget, gpointer user_data) {               \
+    RefPtr menu = static_cast<NativeMenuGtk*>(user_data);    \
+    return menu->On##name_();                                \
+  }
+
+METHOD_SIGNAL(Unmap);
+
+#undef METHOD_SIGNAL
+
+NativeMenuGtk::NativeMenuGtk(dom::Element* aElement)
+    : mMenuModel(MakeRefPtr<MenuModel>(aElement)) {
+  // Floating, so no need to dont_AddRef.
+  mNativeMenu = gtk_menu_new_from_model(mMenuModel->GetModel());
+  gtk_widget_insert_action_group(mNativeMenu.get(), "menu",
+                                 mMenuModel->GetActionGroup());
+  g_signal_connect(mNativeMenu, "unmap", G_CALLBACK(OnUnmapSignal), this);
+}
+
+NativeMenuGtk::~NativeMenuGtk() {
+  g_signal_handlers_disconnect_by_data(mNativeMenu, this);
+}
+
+RefPtr<dom::Element> NativeMenuGtk::Element() { return mMenuModel->Element(); }
+
+void NativeMenuGtk::ShowAsContextMenu(nsIFrame* aClickedFrame,
+                                      const CSSIntPoint& aPosition) {
+  if (mMenuModel->IsShowing()) {
+    return;
+  }
+  RefPtr<nsIWidget> widget = aClickedFrame->PresContext()->GetRootWidget();
+  if (NS_WARN_IF(!widget)) {
+    // XXX Do we need to close menus here?
+    return;
+  }
+  auto* win = static_cast<GdkWindow*>(widget->GetNativeData(NS_NATIVE_WINDOW));
+  if (NS_WARN_IF(!win)) {
+    return;
+  }
+
+  auto* geckoWin = static_cast<nsWindow*>(widget.get());
+  // The position needs to be relative to our window.
+  auto pos = (aPosition * aClickedFrame->PresContext()->CSSToDevPixelScale()) -
+             geckoWin->WidgetToScreenOffset();
+  auto gdkPos = geckoWin->DevicePixelsToGdkPointRoundDown(
+      LayoutDeviceIntPoint::Round(pos));
+
+  mMenuModel->WillShow();
+  const GdkRectangle rect = {gdkPos.x, gdkPos.y, 1, 1};
+  auto openFn = GetPopupAtRectFn();
+  openFn(GTK_MENU(mNativeMenu.get()), win, &rect, GDK_GRAVITY_NORTH_WEST,
+         GDK_GRAVITY_NORTH_WEST, GetLastMousePressEvent());
+
+  RefPtr pin{this};
+  FireEvent(eXULPopupShown);
+}
+
+bool NativeMenuGtk::Close() {
+  if (!mMenuModel->IsShowing()) {
+    return false;
+  }
+  gtk_menu_popdown(GTK_MENU(mNativeMenu.get()));
+  return true;
+}
+
+void NativeMenuGtk::OnUnmap() {
+  FireEvent(eXULPopupHiding);
+
+  mMenuModel->DidHide();
+
+  FireEvent(eXULPopupHidden);
+
+  for (NativeMenu::Observer* observer : mObservers.Clone()) {
+    observer->OnNativeMenuClosed();
+  }
+}
+
+void NativeMenuGtk::ActivateItem(dom::Element* aItemElement, Modifiers,
+                                 int16_t aButton, ErrorResult&) {
+  // TODO: For testing only.
+}
+
+void NativeMenuGtk::OpenSubmenu(dom::Element*) {
+  // TODO: For testing mostly.
+}
+
+void NativeMenuGtk::CloseSubmenu(dom::Element*) {
+  // TODO: For testing mostly.
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/NativeMenuGtk.h b/widget/gtk/NativeMenuGtk.h
new file mode 100644
index 0000000000..345ef58707
--- /dev/null
+++ b/widget/gtk/NativeMenuGtk.h
@@ -0,0 +1,63 @@
+
+/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- */
+/* 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 mozilla_widget_NativeMenuGtk_h
+#define mozilla_widget_NativeMenuGtk_h
+
+#include "mozilla/widget/NativeMenu.h"
+#include "mozilla/EventForwards.h"
+#include "GRefPtr.h"
+
+namespace mozilla {
+
+namespace dom {
+class Element;
+}
+
+namespace widget {
+
+class MenuModel;
+
+class NativeMenuGtk : public NativeMenu {
+ public:
+  // Whether we can use native menu popups on GTK.
+  static bool CanUse();
+
+  explicit NativeMenuGtk(dom::Element* aElement);
+
+  // NativeMenu
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void ShowAsContextMenu(
+      nsIFrame* aClickedFrame, const CSSIntPoint& aPosition) override;
+  bool Close() override;
+  void ActivateItem(dom::Element* aItemElement, Modifiers aModifiers,
+                    int16_t aButton, ErrorResult& aRv) override;
+  void OpenSubmenu(dom::Element* aMenuElement) override;
+  void CloseSubmenu(dom::Element* aMenuElement) override;
+  RefPtr<dom::Element> Element() override;
+  void AddObserver(NativeMenu::Observer* aObserver) override {
+    mObservers.AppendElement(aObserver);
+  }
+  void RemoveObserver(NativeMenu::Observer* aObserver) override {
+    mObservers.RemoveElement(aObserver);
+  }
+
+  MOZ_CAN_RUN_SCRIPT void OnUnmap();
+
+ protected:
+  virtual ~NativeMenuGtk();
+
+  MOZ_CAN_RUN_SCRIPT void FireEvent(EventMessage);
+
+  bool mPoppedUp = false;
+  RefPtr<GtkWidget> mNativeMenu;
+  RefPtr<MenuModel> mMenuModel;
+  nsTArray<NativeMenu::Observer*> mObservers;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif
diff --git a/widget/gtk/NativeMenuSupport.cpp b/widget/gtk/NativeMenuSupport.cpp
new file mode 100644
index 0000000000..4360867fff
--- /dev/null
+++ b/widget/gtk/NativeMenuSupport.cpp
@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/widget/NativeMenuSupport.h"
+
+#include "MainThreadUtils.h"
+#include "NativeMenuGtk.h"
+
+namespace mozilla::widget {
+
+void NativeMenuSupport::CreateNativeMenuBar(nsIWidget* aParent,
+                                            dom::Element* aMenuBarElement) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread(),
+                     "Attempting to create native menu bar on wrong thread!");
+  // TODO
+}
+
+already_AddRefed<NativeMenu> NativeMenuSupport::CreateNativeContextMenu(
+    dom::Element* aPopup) {
+  return MakeAndAddRef<NativeMenuGtk>(aPopup);
+}
+
+bool NativeMenuSupport::ShouldUseNativeContextMenus() {
+  return NativeMenuGtk::CanUse();
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/PCompositorWidget.ipdl b/widget/gtk/PCompositorWidget.ipdl
new file mode 100644
index 0000000000..d554a33144
--- /dev/null
+++ b/widget/gtk/PCompositorWidget.ipdl
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=99: */
+/* 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 protocol PCompositorBridge;
+
+include "mozilla/GfxMessageUtils.h";
+
+using mozilla::LayoutDeviceIntSize from "Units.h";
+
+namespace mozilla {
+namespace widget {
+
+[ManualDealloc, ChildImpl=virtual, ParentImpl=virtual]
+sync protocol PCompositorWidget
+{
+  manager PCompositorBridge;
+
+parent:
+  async __delete__();
+
+  async NotifyClientSizeChanged(LayoutDeviceIntSize aClientSize);
+  async DisableRendering();
+  async EnableRendering(uintptr_t aXWindow, bool aShaped);
+
+child:
+
+  async ObserveVsync();
+  async UnobserveVsync();
+};
+
+} // namespace widget
+} // namespace mozilla
diff --git a/widget/gtk/PlatformWidgetTypes.ipdlh b/widget/gtk/PlatformWidgetTypes.ipdlh
new file mode 100644
index 0000000000..c85da1711e
--- /dev/null
+++ b/widget/gtk/PlatformWidgetTypes.ipdlh
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=99: */
+/* 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 HeadlessWidgetTypes;
+
+include "mozilla/GfxMessageUtils.h";
+
+using mozilla::LayoutDeviceIntSize from "Units.h";
+
+namespace mozilla {
+namespace widget {
+
+struct GtkCompositorWidgetInitData
+{
+  uintptr_t           XWindow;
+  nsCString           XDisplayString;
+  bool                Shaped;
+  bool                IsX11Display;
+
+  LayoutDeviceIntSize InitialClientSize;
+};
+
+union CompositorWidgetInitData
+{
+  GtkCompositorWidgetInitData;
+  HeadlessCompositorWidgetInitData;
+};
+
+} // namespace widget
+} // namespace mozilla
diff --git a/widget/gtk/ScreenHelperGTK.cpp b/widget/gtk/ScreenHelperGTK.cpp
new file mode 100644
index 0000000000..70b72ea5bc
--- /dev/null
+++ b/widget/gtk/ScreenHelperGTK.cpp
@@ -0,0 +1,505 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ScreenHelperGTK.h"
+
+#ifdef MOZ_X11
+#  include <gdk/gdkx.h>
+#endif /* MOZ_X11 */
+#ifdef MOZ_WAYLAND
+#  include <gdk/gdkwayland.h>
+#endif /* MOZ_WAYLAND */
+#include <dlfcn.h>
+#include <gtk/gtk.h>
+
+#include "gfxPlatformGtk.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "mozilla/Logging.h"
+#include "mozilla/WidgetUtilsGtk.h"
+#include "nsGtkUtils.h"
+#include "nsTArray.h"
+#include "nsWindow.h"
+
+#ifdef MOZ_WAYLAND
+#  include "nsWaylandDisplay.h"
+#endif
+
+namespace mozilla::widget {
+
+#ifdef MOZ_LOGGING
+static LazyLogModule sScreenLog("WidgetScreen");
+#  define LOG_SCREEN(...) MOZ_LOG(sScreenLog, LogLevel::Debug, (__VA_ARGS__))
+#else
+#  define LOG_SCREEN(...)
+#endif /* MOZ_LOGGING */
+
+using GdkMonitor = struct _GdkMonitor;
+
+static UniquePtr<ScreenGetter> gScreenGetter;
+struct MonitorConfig {
+  int id = 0;
+  int x = 0;
+  int y = 0;
+  int width_mm = 0;
+  int height_mm = 0;
+  int width = 0;
+  int height = 0;
+  int scale = 0;
+  int refresh = 0;
+
+  explicit MonitorConfig(int aId) : id(aId) {}
+};
+
+static void monitors_changed(GdkScreen* aScreen, gpointer aClosure) {
+  LOG_SCREEN("Received monitors-changed event");
+  auto* self = static_cast<ScreenGetterGtk*>(aClosure);
+  self->RefreshScreens();
+}
+
+static void screen_resolution_changed(GdkScreen* aScreen, GParamSpec* aPspec,
+                                      ScreenGetterGtk* self) {
+  self->RefreshScreens();
+}
+
+static GdkFilterReturn root_window_event_filter(GdkXEvent* aGdkXEvent,
+                                                GdkEvent* aGdkEvent,
+                                                gpointer aClosure) {
+#ifdef MOZ_X11
+  ScreenGetterGtk* self = static_cast<ScreenGetterGtk*>(aClosure);
+  XEvent* xevent = static_cast<XEvent*>(aGdkXEvent);
+
+  switch (xevent->type) {
+    case PropertyNotify: {
+      XPropertyEvent* propertyEvent = &xevent->xproperty;
+      if (propertyEvent->atom == self->NetWorkareaAtom()) {
+        LOG_SCREEN("Work area size changed");
+        self->RefreshScreens();
+      }
+    } break;
+    default:
+      break;
+  }
+#endif
+
+  return GDK_FILTER_CONTINUE;
+}
+
+ScreenGetterGtk::ScreenGetterGtk()
+    : mRootWindow(nullptr)
+#ifdef MOZ_X11
+      ,
+      mNetWorkareaAtom(0)
+#endif
+{
+}
+
+void ScreenGetterGtk::Init() {
+  LOG_SCREEN("ScreenGetterGtk created");
+  GdkScreen* defaultScreen = gdk_screen_get_default();
+  if (!defaultScreen) {
+    // Sometimes we don't initial X (e.g., xpcshell)
+    MOZ_LOG(sScreenLog, LogLevel::Debug,
+            ("defaultScreen is nullptr, running headless"));
+    return;
+  }
+  mRootWindow = gdk_get_default_root_window();
+  MOZ_ASSERT(mRootWindow);
+
+  g_object_ref(mRootWindow);
+
+  // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify
+  gdk_window_set_events(mRootWindow,
+                        GdkEventMask(gdk_window_get_events(mRootWindow) |
+                                     GDK_PROPERTY_CHANGE_MASK));
+
+  g_signal_connect(defaultScreen, "monitors-changed",
+                   G_CALLBACK(monitors_changed), this);
+  // Use _after to ensure this callback is run after gfxPlatformGtk.cpp's
+  // handler.
+  g_signal_connect_after(defaultScreen, "notify::resolution",
+                         G_CALLBACK(screen_resolution_changed), this);
+#ifdef MOZ_X11
+  gdk_window_add_filter(mRootWindow, root_window_event_filter, this);
+  if (GdkIsX11Display()) {
+    mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow),
+                                   "_NET_WORKAREA", X11False);
+  }
+#endif
+  RefreshScreens();
+}
+
+ScreenGetterGtk::~ScreenGetterGtk() {
+  if (mRootWindow) {
+    g_signal_handlers_disconnect_by_data(gdk_screen_get_default(), this);
+
+    gdk_window_remove_filter(mRootWindow, root_window_event_filter, this);
+    g_object_unref(mRootWindow);
+    mRootWindow = nullptr;
+  }
+}
+
+static uint32_t GetGTKPixelDepth() {
+  GdkVisual* visual = gdk_screen_get_system_visual(gdk_screen_get_default());
+  return gdk_visual_get_depth(visual);
+}
+
+static already_AddRefed<Screen> MakeScreenGtk(GdkScreen* aScreen,
+                                              gint aMonitorNum) {
+  gint gdkScaleFactor = ScreenHelperGTK::GetGTKMonitorScaleFactor(aMonitorNum);
+
+  // gdk_screen_get_monitor_geometry / workarea returns application pixels
+  // (desktop pixels), so we need to convert it to device pixels with
+  // gdkScaleFactor.
+  gint geometryScaleFactor = gdkScaleFactor;
+
+  LayoutDeviceIntRect rect;
+
+  gint refreshRate = [&] {
+    // Since gtk 3.22
+    static auto s_gdk_display_get_monitor = (GdkMonitor * (*)(GdkDisplay*, int))
+        dlsym(RTLD_DEFAULT, "gdk_display_get_monitor");
+    static auto s_gdk_monitor_get_refresh_rate = (int (*)(GdkMonitor*))dlsym(
+        RTLD_DEFAULT, "gdk_monitor_get_refresh_rate");
+
+    if (!s_gdk_monitor_get_refresh_rate) {
+      return 0;
+    }
+    GdkMonitor* monitor =
+        s_gdk_display_get_monitor(gdk_display_get_default(), aMonitorNum);
+    if (!monitor) {
+      return 0;
+    }
+    // Convert to Hz.
+    return NSToIntRound(s_gdk_monitor_get_refresh_rate(monitor) / 1000.0f);
+  }();
+
+  GdkRectangle workarea;
+  gdk_screen_get_monitor_workarea(aScreen, aMonitorNum, &workarea);
+  LayoutDeviceIntRect availRect(workarea.x * geometryScaleFactor,
+                                workarea.y * geometryScaleFactor,
+                                workarea.width * geometryScaleFactor,
+                                workarea.height * geometryScaleFactor);
+  if (GdkIsX11Display()) {
+    GdkRectangle monitor;
+    gdk_screen_get_monitor_geometry(aScreen, aMonitorNum, &monitor);
+    rect = LayoutDeviceIntRect(monitor.x * geometryScaleFactor,
+                               monitor.y * geometryScaleFactor,
+                               monitor.width * geometryScaleFactor,
+                               monitor.height * geometryScaleFactor);
+  } else {
+    // We use Gtk workarea on Wayland as it matches our needs (Bug 1732682).
+    rect = availRect;
+  }
+
+  uint32_t pixelDepth = GetGTKPixelDepth();
+
+  // Use per-monitor scaling factor in gtk/wayland, or 1.0 otherwise.
+  DesktopToLayoutDeviceScale contentsScale(1.0);
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay()) {
+    contentsScale.scale = gdkScaleFactor;
+  }
+#endif
+
+  CSSToLayoutDeviceScale defaultCssScale(gdkScaleFactor);
+
+  float dpi = 96.0f;
+  gint heightMM = gdk_screen_get_monitor_height_mm(aScreen, aMonitorNum);
+  if (heightMM > 0) {
+    dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
+  }
+
+  LOG_SCREEN(
+      "New monitor %d size [%d,%d -> %d x %d] depth %d scale %f CssScale %f  "
+      "DPI %f refresh %d ]",
+      aMonitorNum, rect.x, rect.y, rect.width, rect.height, pixelDepth,
+      contentsScale.scale, defaultCssScale.scale, dpi, refreshRate);
+  return MakeAndAddRef<Screen>(rect, availRect, pixelDepth, pixelDepth,
+                               refreshRate, contentsScale, defaultCssScale, dpi,
+                               Screen::IsPseudoDisplay::No);
+}
+
+void ScreenGetterGtk::RefreshScreens() {
+  LOG_SCREEN("ScreenGetterGtk::RefreshScreens()");
+  AutoTArray<RefPtr<Screen>, 4> screenList;
+
+  GdkScreen* defaultScreen = gdk_screen_get_default();
+  gint numScreens = gdk_screen_get_n_monitors(defaultScreen);
+  LOG_SCREEN("GDK reports %d screens", numScreens);
+
+  for (gint i = 0; i < numScreens; i++) {
+    screenList.AppendElement(MakeScreenGtk(defaultScreen, i));
+  }
+
+  ScreenManager::Refresh(std::move(screenList));
+}
+
+#ifdef MOZ_WAYLAND
+static void output_handle_geometry(void* data, struct wl_output* wl_output,
+                                   int x, int y, int physical_width,
+                                   int physical_height, int subpixel,
+                                   const char* make, const char* model,
+                                   int32_t transform) {
+  auto* monitor = static_cast<MonitorConfig*>(data);
+  LOG_SCREEN(
+      "wl_output: geometry position %d %d physical size %d %d, subpixel %d, "
+      "transform %d",
+      x, y, physical_width, physical_height, subpixel, transform);
+  monitor->x = x;
+  monitor->y = y;
+  monitor->width_mm = physical_width;
+  monitor->height_mm = physical_height;
+}
+
+static void output_handle_done(void* data, struct wl_output* wl_output) {
+  LOG_SCREEN("done");
+  gScreenGetter->RefreshScreens();
+}
+
+static void output_handle_scale(void* data, struct wl_output* wl_output,
+                                int32_t scale) {
+  auto* monitor = static_cast<MonitorConfig*>(data);
+  LOG_SCREEN("wl_output: scale %d", scale);
+  monitor->scale = scale;
+}
+
+static void output_handle_mode(void* data, struct wl_output* wl_output,
+                               uint32_t flags, int width, int height,
+                               int refresh) {
+  auto* monitor = static_cast<MonitorConfig*>(data);
+  LOG_SCREEN("wl_output: mode output size %d x %d refresh %d", width, height,
+             refresh);
+
+  if ((flags & WL_OUTPUT_MODE_CURRENT) == 0) return;
+
+  monitor->refresh = NSToIntRound(refresh / 1000.0f);
+  monitor->width = width;
+  monitor->height = height;
+}
+
+static const struct wl_output_listener output_listener = {
+    output_handle_geometry,
+    output_handle_mode,
+    output_handle_done,
+    output_handle_scale,
+};
+
+static void screen_registry_handler(void* data, wl_registry* registry,
+                                    uint32_t id, const char* interface,
+                                    uint32_t version) {
+  auto* getter = static_cast<ScreenGetterWayland*>(data);
+  if (strcmp(interface, "wl_output") == 0 && version > 1) {
+    auto* output =
+        WaylandRegistryBind<wl_output>(registry, id, &wl_output_interface, 2);
+    wl_output_add_listener(output, &output_listener,
+                           getter->AddMonitorConfig(id));
+  }
+}
+
+static void screen_registry_remover(void* data, struct wl_registry* registry,
+                                    uint32_t id) {
+  auto* getter = static_cast<ScreenGetterWayland*>(data);
+  if (getter->RemoveMonitorConfig(id)) {
+    getter->RefreshScreens();
+  }
+  /* TODO: the object needs to be destroyed here, we're leaking */
+}
+
+static const struct wl_registry_listener screen_registry_listener = {
+    screen_registry_handler, screen_registry_remover};
+
+void ScreenGetterWayland::Init() {
+  MOZ_ASSERT(GdkIsWaylandDisplay());
+  LOG_SCREEN("ScreenGetterWayland created");
+  wl_display* display = WaylandDisplayGetWLDisplay();
+  mRegistry = wl_display_get_registry(display);
+  wl_registry_add_listener((wl_registry*)mRegistry, &screen_registry_listener,
+                           this);
+  wl_display_roundtrip(display);
+  wl_display_roundtrip(display);
+}
+
+MonitorConfig* ScreenGetterWayland::AddMonitorConfig(int aId) {
+  LOG_SCREEN("Add Monitor ID %d num %d", aId, (int)(mMonitors.Length() - 1));
+  UniquePtr<MonitorConfig> monitor = MakeUnique<MonitorConfig>(aId);
+  mMonitors.AppendElement(std::move(monitor));
+  return mMonitors.LastElement().get();
+}
+
+bool ScreenGetterWayland::RemoveMonitorConfig(int aId) {
+  for (unsigned int i = 0; i < mMonitors.Length(); i++) {
+    if (mMonitors[i]->id == aId) {
+      LOG_SCREEN("Remove Monitor ID %d num %d", aId, i);
+      mMonitors.RemoveElementAt(i);
+      return true;
+    }
+  }
+  return false;
+}
+
+ScreenGetterWayland::ScreenGetterWayland() = default;
+
+ScreenGetterWayland::~ScreenGetterWayland() {
+  MozClearPointer(mRegistry, wl_registry_destroy);
+}
+
+static bool GdkMonitorGetWorkarea(GdkMonitor* monitor, GdkRectangle* workarea) {
+  static auto s_gdk_monitor_get_workarea =
+      (void (*)(GdkMonitor*, GdkRectangle*))dlsym(RTLD_DEFAULT,
+                                                  "gdk_monitor_get_workarea");
+  if (!s_gdk_monitor_get_workarea) {
+    return false;
+  }
+
+  s_gdk_monitor_get_workarea(monitor, workarea);
+  return true;
+}
+
+already_AddRefed<Screen> ScreenGetterWayland::MakeScreenWayland(gint aMonitor) {
+  MonitorConfig* monitor = mMonitors[aMonitor].get();
+
+  // On GNOME/Mutter we use results from wl_output directly
+  LayoutDeviceIntRect rect(monitor->x, monitor->y, monitor->width,
+                           monitor->height);
+
+  uint32_t pixelDepth = GetGTKPixelDepth();
+
+  // Use per-monitor scaling factor in gtk/wayland, or 1.0 otherwise.
+  DesktopToLayoutDeviceScale contentsScale(monitor->scale);
+
+  CSSToLayoutDeviceScale defaultCssScale(monitor->scale);
+
+  float dpi = 96.0f;
+  gint heightMM = monitor->height_mm;
+  if (heightMM > 0) {
+    dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
+  }
+
+  LOG_SCREEN(
+      "Monitor %d [%d %d -> %d x %d depth %d content scale %f css scale %f "
+      "DPI %f, refresh %d]",
+      aMonitor, rect.x, rect.y, rect.width, rect.height, pixelDepth,
+      contentsScale.scale, defaultCssScale.scale, dpi, monitor->refresh);
+
+  // We report zero screen shift on Wayland. All popups positions are relative
+  // to toplevel and we can't get toplevel position from Wayland compositor.
+  rect.x = rect.y = 0;
+  return MakeAndAddRef<Screen>(rect, rect, pixelDepth, pixelDepth,
+                               monitor->refresh, contentsScale, defaultCssScale,
+                               dpi, Screen::IsPseudoDisplay::No);
+}
+
+void ScreenGetterWayland::RefreshScreens() {
+  LOG_SCREEN("ScreenGetterWayland::RefreshScreens()");
+  AutoTArray<RefPtr<Screen>, 4> managerScreenList;
+
+  mScreenList.Clear();
+  const gint numScreens = mMonitors.Length();
+  LOG_SCREEN("Wayland reports %d monitors", numScreens);
+  for (gint i = 0; i < numScreens; i++) {
+    RefPtr<Screen> screen = MakeScreenWayland(i);
+    mScreenList.AppendElement(screen);
+    managerScreenList.AppendElement(screen);
+  }
+
+  ScreenManager::Refresh(std::move(managerScreenList));
+}
+
+int ScreenGetterWayland::GetMonitorForWindow(nsWindow* aWindow) {
+  LOG_SCREEN("GetMonitorForWindow() [%p]", aWindow);
+
+  static auto s_gdk_display_get_monitor_at_window =
+      (GdkMonitor * (*)(GdkDisplay*, GdkWindow*))
+          dlsym(RTLD_DEFAULT, "gdk_display_get_monitor_at_window");
+
+  if (!s_gdk_display_get_monitor_at_window) {
+    LOG_SCREEN("  failed, missing Gtk helpers");
+    return -1;
+  }
+
+  GdkWindow* gdkWindow = gtk_widget_get_window(aWindow->GetGtkWidget());
+  if (!gdkWindow) {
+    LOG_SCREEN("  failed, can't get GdkWindow");
+    return -1;
+  }
+
+  GdkMonitor* monitor =
+      s_gdk_display_get_monitor_at_window(gdk_display_get_default(), gdkWindow);
+  if (!monitor) {
+    LOG_SCREEN("  failed, can't get monitor for GdkWindow");
+    return -1;
+  }
+
+  GdkRectangle workArea;
+  if (!GdkMonitorGetWorkarea(monitor, &workArea)) {
+    LOG_SCREEN("  failed, can't get work area");
+    return -1;
+  }
+
+  for (unsigned int i = 0; i < mMonitors.Length(); i++) {
+    // Although Gtk/Mutter is very creative in reporting various screens sizes
+    // we can rely on Gtk work area start position to match wl_output.
+    if (mMonitors[i]->x == workArea.x && mMonitors[i]->y == workArea.y) {
+      LOG_SCREEN(" monitor %d work area [%d, %d] -> (%d x %d) scale %d", i,
+                 mMonitors[i]->x, mMonitors[i]->y, mMonitors[i]->width,
+                 mMonitors[i]->height, mMonitors[i]->scale);
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+RefPtr<nsIScreen> ScreenGetterWayland::GetScreenForWindow(nsWindow* aWindow) {
+  if (mMonitors.IsEmpty()) {
+    return nullptr;
+  }
+
+  int monitor = GetMonitorForWindow(aWindow);
+  if (monitor < 0) {
+    return nullptr;
+  }
+
+  if (mMonitors.Length() != mScreenList.Length()) {
+    // Gtk list of GtkScreens are out of sync with our monitor list.
+    // Try to refresh it now.
+    RefreshScreens();
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT((unsigned)monitor < mScreenList.Length(),
+                        "We're missing screen?");
+  return mScreenList[monitor];
+}
+#endif
+
+RefPtr<nsIScreen> ScreenHelperGTK::GetScreenForWindow(nsWindow* aWindow) {
+  return gScreenGetter->GetScreenForWindow(aWindow);
+}
+
+gint ScreenHelperGTK::GetGTKMonitorScaleFactor(gint aMonitorNum) {
+  GdkScreen* screen = gdk_screen_get_default();
+  return gdk_screen_get_monitor_scale_factor(screen, aMonitorNum);
+}
+
+ScreenHelperGTK::ScreenHelperGTK() {
+#ifdef MOZ_WAYLAND
+  // Use ScreenGetterWayland on Gnome/Mutter only. It uses additional wl_output
+  // to track screen size changes (which are wrongly reported by mutter)
+  // and causes issues on Sway (Bug 1730476).
+  // https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/3941
+  if (GdkIsWaylandDisplay() && IsGnomeDesktopEnvironment()) {
+    gScreenGetter = MakeUnique<ScreenGetterWayland>();
+  }
+#endif
+  if (!gScreenGetter) {
+    gScreenGetter = MakeUnique<ScreenGetterGtk>();
+  }
+  gScreenGetter->Init();
+}
+
+ScreenHelperGTK::~ScreenHelperGTK() { gScreenGetter = nullptr; }
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/ScreenHelperGTK.h b/widget/gtk/ScreenHelperGTK.h
new file mode 100644
index 0000000000..d3b0ca6fa9
--- /dev/null
+++ b/widget/gtk/ScreenHelperGTK.h
@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_widget_gtk_ScreenHelperGTK_h
+#define mozilla_widget_gtk_ScreenHelperGTK_h
+
+#include "mozilla/widget/ScreenManager.h"
+
+#include "gdk/gdk.h"
+#ifdef MOZ_X11
+#  include <X11/Xlib.h>
+#  include "X11UndefineNone.h"
+#endif
+
+class nsWindow;
+struct wl_registry;
+
+namespace mozilla {
+namespace widget {
+
+class ScreenGetter {
+ public:
+  ScreenGetter() = default;
+  virtual ~ScreenGetter(){};
+
+  virtual void Init(){};
+
+  virtual void RefreshScreens(){};
+  virtual RefPtr<nsIScreen> GetScreenForWindow(nsWindow* aWindow) {
+    return nullptr;
+  }
+};
+
+class ScreenGetterGtk : public ScreenGetter {
+ public:
+  ScreenGetterGtk();
+  ~ScreenGetterGtk();
+
+  void Init();
+
+#ifdef MOZ_X11
+  Atom NetWorkareaAtom() { return mNetWorkareaAtom; }
+#endif
+
+  // For internal use from signal callback functions
+  void RefreshScreens();
+
+ private:
+  GdkWindow* mRootWindow;
+#ifdef MOZ_X11
+  Atom mNetWorkareaAtom;
+#endif
+};
+
+class ScreenGetterWayland;
+struct MonitorConfig;
+
+#ifdef MOZ_WAYLAND
+class ScreenGetterWayland : public ScreenGetter {
+ public:
+  ScreenGetterWayland();
+  ~ScreenGetterWayland();
+
+  void Init();
+
+  MonitorConfig* AddMonitorConfig(int aId);
+  bool RemoveMonitorConfig(int aId);
+  already_AddRefed<Screen> MakeScreenWayland(gint aMonitor);
+
+  RefPtr<nsIScreen> GetScreenForWindow(nsWindow* aWindow);
+
+  // For internal use from signal callback functions
+  void RefreshScreens();
+
+ private:
+  int GetMonitorForWindow(nsWindow* aWindow);
+  bool MonitorUsesNonIntegerScale(int aMonitor);
+
+ private:
+  wl_registry* mRegistry = nullptr;
+  // We use UniquePtr<> here to ensure that MonitorConfig is heap-allocated
+  // so it's not invalidated by any change to mMonitors that could happen in the
+  // meantime.
+  AutoTArray<UniquePtr<MonitorConfig>, 4> mMonitors;
+  AutoTArray<RefPtr<Screen>, 4> mScreenList;
+};
+#endif
+
+class ScreenHelperGTK final : public ScreenManager::Helper {
+ public:
+  ScreenHelperGTK();
+  ~ScreenHelperGTK();
+
+  static gint GetGTKMonitorScaleFactor(gint aMonitorNum = 0);
+  static RefPtr<nsIScreen> GetScreenForWindow(nsWindow* aWindow);
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // mozilla_widget_gtk_ScreenHelperGTK_h
diff --git a/widget/gtk/TaskbarProgress.cpp b/widget/gtk/TaskbarProgress.cpp
new file mode 100644
index 0000000000..396f39b5e7
--- /dev/null
+++ b/widget/gtk/TaskbarProgress.cpp
@@ -0,0 +1,106 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Logging.h"
+
+#include "TaskbarProgress.h"
+#include "nsWindow.h"
+#include "WidgetUtils.h"
+#include "nsPIDOMWindow.h"
+
+using mozilla::LogLevel;
+static mozilla::LazyLogModule gGtkTaskbarProgressLog("nsIGtkTaskbarProgress");
+
+/******************************************************************************
+ * TaskbarProgress
+ ******************************************************************************/
+
+NS_IMPL_ISUPPORTS(TaskbarProgress, nsIGtkTaskbarProgress, nsITaskbarProgress)
+
+TaskbarProgress::TaskbarProgress() : mPrimaryWindow(nullptr) {
+  MOZ_LOG(gGtkTaskbarProgressLog, LogLevel::Info,
+          ("%p TaskbarProgress()", this));
+}
+
+TaskbarProgress::~TaskbarProgress() {
+  MOZ_LOG(gGtkTaskbarProgressLog, LogLevel::Info,
+          ("%p ~TaskbarProgress()", this));
+}
+
+NS_IMETHODIMP
+TaskbarProgress::SetProgressState(nsTaskbarProgressState aState,
+                                  uint64_t aCurrentValue, uint64_t aMaxValue) {
+  NS_ENSURE_ARG_RANGE(aState, 0, STATE_PAUSED);
+
+  if (aState == STATE_NO_PROGRESS || aState == STATE_INDETERMINATE) {
+    NS_ENSURE_TRUE(aCurrentValue == 0, NS_ERROR_INVALID_ARG);
+    NS_ENSURE_TRUE(aMaxValue == 0, NS_ERROR_INVALID_ARG);
+  }
+
+  NS_ENSURE_TRUE((aCurrentValue <= aMaxValue), NS_ERROR_ILLEGAL_VALUE);
+
+  // See TaskbarProgress::SetPrimaryWindow: if we're running in headless
+  // mode, mPrimaryWindow will be null.
+  if (!mPrimaryWindow) {
+    return NS_OK;
+  }
+
+  gulong progress;
+
+  if (aMaxValue == 0) {
+    progress = 0;
+  } else {
+    // Rounding down to ensure we don't set to 'full' until the operation
+    // is completely finished.
+    progress = (gulong)(((double)aCurrentValue / aMaxValue) * 100.0);
+  }
+
+  // Check if the resultant value is the same as the previous call, and
+  // ignore this update if it is.
+
+  if (progress == mCurrentProgress) {
+    return NS_OK;
+  }
+
+  mCurrentProgress = progress;
+
+  MOZ_LOG(gGtkTaskbarProgressLog, LogLevel::Debug,
+          ("GtkTaskbarProgress::SetProgressState progress: %lu", progress));
+
+  mPrimaryWindow->SetProgress(progress);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TaskbarProgress::SetPrimaryWindow(mozIDOMWindowProxy* aWindow) {
+  NS_ENSURE_TRUE(aWindow != nullptr, NS_ERROR_ILLEGAL_VALUE);
+
+  auto* parent = nsPIDOMWindowOuter::From(aWindow);
+  RefPtr<nsIWidget> widget =
+      mozilla::widget::WidgetUtils::DOMWindowToWidget(parent);
+
+  // Only nsWindows have a native window, HeadlessWidgets do not.  Stop here if
+  // the window does not have one.
+  if (!widget->GetNativeData(NS_NATIVE_WINDOW)) {
+    return NS_OK;
+  }
+
+  mPrimaryWindow = static_cast<nsWindow*>(widget.get());
+
+  // Clear our current progress.  We get a forced update from the
+  // DownloadsTaskbar after returning from this function - zeroing out our
+  // progress will make sure the new window gets the property set on it
+  // immediately, rather than waiting for the progress value to change (which
+  // could be a while depending on size.)
+  mCurrentProgress = 0;
+
+  MOZ_LOG(gGtkTaskbarProgressLog, LogLevel::Debug,
+          ("GtkTaskbarProgress::SetPrimaryWindow window: %p",
+           mPrimaryWindow.get()));
+
+  return NS_OK;
+}
diff --git a/widget/gtk/TaskbarProgress.h b/widget/gtk/TaskbarProgress.h
new file mode 100644
index 0000000000..819df0c089
--- /dev/null
+++ b/widget/gtk/TaskbarProgress.h
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 2; 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 TaskbarProgress_h_
+#define TaskbarProgress_h_
+
+#include "nsIGtkTaskbarProgress.h"
+
+class nsWindow;
+
+class TaskbarProgress final : public nsIGtkTaskbarProgress {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIGTKTASKBARPROGRESS
+  NS_DECL_NSITASKBARPROGRESS
+
+  TaskbarProgress();
+
+ protected:
+  ~TaskbarProgress();
+
+  // We track the progress value so we can avoid updating the X window property
+  // unnecessarily.
+  unsigned long mCurrentProgress;
+
+  RefPtr<nsWindow> mPrimaryWindow;
+};
+
+#endif  // #ifndef TaskbarProgress_h_
diff --git a/widget/gtk/WakeLockListener.cpp b/widget/gtk/WakeLockListener.cpp
new file mode 100644
index 0000000000..2b71b97ea4
--- /dev/null
+++ b/widget/gtk/WakeLockListener.cpp
@@ -0,0 +1,546 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifdef MOZ_ENABLE_DBUS
+
+#  include "WakeLockListener.h"
+
+#  include <dbus/dbus.h>
+#  include <dbus/dbus-glib-lowlevel.h>
+
+#  include "WidgetUtilsGtk.h"
+
+#  if defined(MOZ_X11)
+#    include "prlink.h"
+#    include <gdk/gdk.h>
+#    include <gdk/gdkx.h>
+#    include "X11UndefineNone.h"
+#  endif
+
+#  if defined(MOZ_WAYLAND)
+#    include "mozilla/widget/nsWaylandDisplay.h"
+#    include "nsWindow.h"
+#    include "mozilla/dom/power/PowerManagerService.h"
+#  endif
+
+#  define FREEDESKTOP_SCREENSAVER_TARGET "org.freedesktop.ScreenSaver"
+#  define FREEDESKTOP_SCREENSAVER_OBJECT "/ScreenSaver"
+#  define FREEDESKTOP_SCREENSAVER_INTERFACE "org.freedesktop.ScreenSaver"
+
+#  define FREEDESKTOP_POWER_TARGET "org.freedesktop.PowerManagement"
+#  define FREEDESKTOP_POWER_OBJECT "/org/freedesktop/PowerManagement/Inhibit"
+#  define FREEDESKTOP_POWER_INTERFACE "org.freedesktop.PowerManagement.Inhibit"
+
+#  define SESSION_MANAGER_TARGET "org.gnome.SessionManager"
+#  define SESSION_MANAGER_OBJECT "/org/gnome/SessionManager"
+#  define SESSION_MANAGER_INTERFACE "org.gnome.SessionManager"
+
+#  define DBUS_TIMEOUT (-1)
+
+using namespace mozilla;
+using namespace mozilla::widget;
+
+NS_IMPL_ISUPPORTS(WakeLockListener, nsIDOMMozWakeLockListener)
+
+StaticRefPtr<WakeLockListener> WakeLockListener::sSingleton;
+
+#  define WAKE_LOCK_LOG(...) \
+    MOZ_LOG(gLinuxWakeLockLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+static mozilla::LazyLogModule gLinuxWakeLockLog("LinuxWakeLock");
+
+enum WakeLockDesktopEnvironment {
+  FreeDesktopScreensaver,
+  FreeDesktopPower,
+  GNOME,
+#  if defined(MOZ_X11)
+  XScreenSaver,
+#  endif
+#  if defined(MOZ_WAYLAND)
+  WaylandIdleInhibit,
+#  endif
+  Unsupported,
+};
+
+class WakeLockTopic {
+ public:
+  WakeLockTopic(const nsAString& aTopic, DBusConnection* aConnection)
+      :
+#  if defined(MOZ_WAYLAND)
+        mWaylandInhibitor(nullptr),
+#  endif
+        mTopic(NS_ConvertUTF16toUTF8(aTopic)),
+        mConnection(aConnection),
+        mDesktopEnvironment(FreeDesktopScreensaver),
+        mInhibitRequest(0),
+        mShouldInhibit(false),
+        mWaitingForReply(false) {
+  }
+
+  nsresult InhibitScreensaver(void);
+  nsresult UninhibitScreensaver(void);
+
+ private:
+  bool SendInhibit();
+  bool SendUninhibit();
+
+  bool SendFreeDesktopPowerInhibitMessage();
+  bool SendFreeDesktopScreensaverInhibitMessage();
+  bool SendGNOMEInhibitMessage();
+  bool SendMessage(DBusMessage* aMessage);
+
+#  if defined(MOZ_X11)
+  static bool CheckXScreenSaverSupport();
+  static bool InhibitXScreenSaver(bool inhibit);
+#  endif
+
+#  if defined(MOZ_WAYLAND)
+  zwp_idle_inhibitor_v1* mWaylandInhibitor;
+  static bool CheckWaylandIdleInhibitSupport();
+  bool InhibitWaylandIdle();
+  bool UninhibitWaylandIdle();
+#  endif
+
+  static void ReceiveInhibitReply(DBusPendingCall* aPending, void* aUserData);
+  void InhibitFailed();
+  void InhibitSucceeded(uint32_t aInhibitRequest);
+
+  nsCString mTopic;
+  RefPtr<DBusConnection> mConnection;
+
+  WakeLockDesktopEnvironment mDesktopEnvironment;
+
+  uint32_t mInhibitRequest;
+
+  bool mShouldInhibit;
+  bool mWaitingForReply;
+};
+
+bool WakeLockTopic::SendMessage(DBusMessage* aMessage) {
+  // send message and get a handle for a reply
+  RefPtr<DBusPendingCall> reply;
+  dbus_connection_send_with_reply(mConnection, aMessage,
+                                  reply.StartAssignment(), DBUS_TIMEOUT);
+  if (!reply) {
+    return false;
+  }
+
+  dbus_pending_call_set_notify(reply, &ReceiveInhibitReply, this, NULL);
+
+  return true;
+}
+
+bool WakeLockTopic::SendFreeDesktopPowerInhibitMessage() {
+  RefPtr<DBusMessage> message =
+      already_AddRefed<DBusMessage>(dbus_message_new_method_call(
+          FREEDESKTOP_POWER_TARGET, FREEDESKTOP_POWER_OBJECT,
+          FREEDESKTOP_POWER_INTERFACE, "Inhibit"));
+
+  if (!message) {
+    return false;
+  }
+
+  const char* app = g_get_prgname();
+  const char* topic = mTopic.get();
+  dbus_message_append_args(message, DBUS_TYPE_STRING, &app, DBUS_TYPE_STRING,
+                           &topic, DBUS_TYPE_INVALID);
+
+  return SendMessage(message);
+}
+
+bool WakeLockTopic::SendFreeDesktopScreensaverInhibitMessage() {
+  RefPtr<DBusMessage> message =
+      already_AddRefed<DBusMessage>(dbus_message_new_method_call(
+          FREEDESKTOP_SCREENSAVER_TARGET, FREEDESKTOP_SCREENSAVER_OBJECT,
+          FREEDESKTOP_SCREENSAVER_INTERFACE, "Inhibit"));
+
+  if (!message) {
+    return false;
+  }
+
+  const char* app = g_get_prgname();
+  const char* topic = mTopic.get();
+  dbus_message_append_args(message, DBUS_TYPE_STRING, &app, DBUS_TYPE_STRING,
+                           &topic, DBUS_TYPE_INVALID);
+
+  return SendMessage(message);
+}
+
+bool WakeLockTopic::SendGNOMEInhibitMessage() {
+  RefPtr<DBusMessage> message =
+      already_AddRefed<DBusMessage>(dbus_message_new_method_call(
+          SESSION_MANAGER_TARGET, SESSION_MANAGER_OBJECT,
+          SESSION_MANAGER_INTERFACE, "Inhibit"));
+
+  if (!message) {
+    return false;
+  }
+
+  static const uint32_t xid = 0;
+  static const uint32_t flags = (1 << 3);  // Inhibit idle
+  const char* app = g_get_prgname();
+  const char* topic = mTopic.get();
+  dbus_message_append_args(message, DBUS_TYPE_STRING, &app, DBUS_TYPE_UINT32,
+                           &xid, DBUS_TYPE_STRING, &topic, DBUS_TYPE_UINT32,
+                           &flags, DBUS_TYPE_INVALID);
+
+  return SendMessage(message);
+}
+
+#  if defined(MOZ_X11)
+
+typedef Bool (*_XScreenSaverQueryExtension_fn)(Display* dpy, int* event_base,
+                                               int* error_base);
+typedef Bool (*_XScreenSaverQueryVersion_fn)(Display* dpy, int* major,
+                                             int* minor);
+typedef void (*_XScreenSaverSuspend_fn)(Display* dpy, Bool suspend);
+
+static PRLibrary* sXssLib = nullptr;
+static _XScreenSaverQueryExtension_fn _XSSQueryExtension = nullptr;
+static _XScreenSaverQueryVersion_fn _XSSQueryVersion = nullptr;
+static _XScreenSaverSuspend_fn _XSSSuspend = nullptr;
+
+/* static */
+bool WakeLockTopic::CheckXScreenSaverSupport() {
+  if (!sXssLib) {
+    sXssLib = PR_LoadLibrary("libXss.so.1");
+    if (!sXssLib) {
+      return false;
+    }
+  }
+
+  _XSSQueryExtension = (_XScreenSaverQueryExtension_fn)PR_FindFunctionSymbol(
+      sXssLib, "XScreenSaverQueryExtension");
+  _XSSQueryVersion = (_XScreenSaverQueryVersion_fn)PR_FindFunctionSymbol(
+      sXssLib, "XScreenSaverQueryVersion");
+  _XSSSuspend = (_XScreenSaverSuspend_fn)PR_FindFunctionSymbol(
+      sXssLib, "XScreenSaverSuspend");
+  if (!_XSSQueryExtension || !_XSSQueryVersion || !_XSSSuspend) {
+    return false;
+  }
+
+  GdkDisplay* gDisplay = gdk_display_get_default();
+  if (!GdkIsX11Display(gDisplay)) {
+    return false;
+  }
+  Display* display = GDK_DISPLAY_XDISPLAY(gDisplay);
+
+  int throwaway;
+  if (!_XSSQueryExtension(display, &throwaway, &throwaway)) return false;
+
+  int major, minor;
+  if (!_XSSQueryVersion(display, &major, &minor)) return false;
+  // Needs to be compatible with version 1.1
+  if (major != 1) return false;
+  if (minor < 1) return false;
+
+  return true;
+}
+
+/* static */
+bool WakeLockTopic::InhibitXScreenSaver(bool inhibit) {
+  // Should only be called if CheckXScreenSaverSupport returns true.
+  // There's a couple of safety checks here nonetheless.
+  if (!_XSSSuspend) {
+    return false;
+  }
+  GdkDisplay* gDisplay = gdk_display_get_default();
+  if (!GdkIsX11Display(gDisplay)) {
+    return false;
+  }
+  Display* display = GDK_DISPLAY_XDISPLAY(gDisplay);
+  _XSSSuspend(display, inhibit);
+  return true;
+}
+
+#  endif
+
+#  if defined(MOZ_WAYLAND)
+
+/* static */
+bool WakeLockTopic::CheckWaylandIdleInhibitSupport() {
+  RefPtr<nsWaylandDisplay> waylandDisplay = WaylandDisplayGet();
+  return waylandDisplay && waylandDisplay->GetIdleInhibitManager() != nullptr;
+}
+
+bool WakeLockTopic::InhibitWaylandIdle() {
+  RefPtr<nsWaylandDisplay> waylandDisplay = WaylandDisplayGet();
+  if (!waylandDisplay) {
+    return false;
+  }
+
+  nsWindow* focusedWindow = nsWindow::GetFocusedWindow();
+  if (!focusedWindow) {
+    return false;
+  }
+
+  UninhibitWaylandIdle();
+
+  MozContainerSurfaceLock lock(focusedWindow->GetMozContainer());
+  struct wl_surface* waylandSurface = lock.GetSurface();
+  if (waylandSurface) {
+    mWaylandInhibitor = zwp_idle_inhibit_manager_v1_create_inhibitor(
+        waylandDisplay->GetIdleInhibitManager(), waylandSurface);
+  }
+  return true;
+}
+
+bool WakeLockTopic::UninhibitWaylandIdle() {
+  if (mWaylandInhibitor == nullptr) return false;
+
+  zwp_idle_inhibitor_v1_destroy(mWaylandInhibitor);
+  mWaylandInhibitor = nullptr;
+
+  return true;
+}
+
+#  endif
+
+bool WakeLockTopic::SendInhibit() {
+  bool sendOk = false;
+
+  switch (mDesktopEnvironment) {
+    case FreeDesktopScreensaver:
+      WAKE_LOCK_LOG("SendInhibit(): FreeDesktopScreensaver");
+      sendOk = SendFreeDesktopScreensaverInhibitMessage();
+      break;
+    case FreeDesktopPower:
+      WAKE_LOCK_LOG("SendInhibit(): FreeDesktopPower");
+      sendOk = SendFreeDesktopPowerInhibitMessage();
+      break;
+    case GNOME:
+      WAKE_LOCK_LOG("SendInhibit(): GNOME");
+      sendOk = SendGNOMEInhibitMessage();
+      break;
+#  if defined(MOZ_X11)
+    case XScreenSaver:
+      WAKE_LOCK_LOG("SendInhibit(): InhibitXScreenSaver");
+      return InhibitXScreenSaver(true);
+#  endif
+#  if defined(MOZ_WAYLAND)
+    case WaylandIdleInhibit:
+      WAKE_LOCK_LOG("SendInhibit(): WaylandIdleInhibit");
+      return InhibitWaylandIdle();
+#  endif
+    case Unsupported:
+      return false;
+  }
+
+  if (sendOk) {
+    mWaitingForReply = true;
+  }
+
+  return sendOk;
+}
+
+bool WakeLockTopic::SendUninhibit() {
+  RefPtr<DBusMessage> message;
+
+  if (mDesktopEnvironment == FreeDesktopScreensaver) {
+    WAKE_LOCK_LOG("SendUninhibit(): FreeDesktopScreensaver");
+    message = already_AddRefed<DBusMessage>(dbus_message_new_method_call(
+        FREEDESKTOP_SCREENSAVER_TARGET, FREEDESKTOP_SCREENSAVER_OBJECT,
+        FREEDESKTOP_SCREENSAVER_INTERFACE, "UnInhibit"));
+  } else if (mDesktopEnvironment == FreeDesktopPower) {
+    WAKE_LOCK_LOG("SendUninhibit(): FreeDesktopPower");
+    message = already_AddRefed<DBusMessage>(dbus_message_new_method_call(
+        FREEDESKTOP_POWER_TARGET, FREEDESKTOP_POWER_OBJECT,
+        FREEDESKTOP_POWER_INTERFACE, "UnInhibit"));
+  } else if (mDesktopEnvironment == GNOME) {
+    WAKE_LOCK_LOG("SendUninhibit(): GNOME");
+    message = already_AddRefed<DBusMessage>(dbus_message_new_method_call(
+        SESSION_MANAGER_TARGET, SESSION_MANAGER_OBJECT,
+        SESSION_MANAGER_INTERFACE, "Uninhibit"));
+  }
+#  if defined(MOZ_X11)
+  else if (mDesktopEnvironment == XScreenSaver) {
+    WAKE_LOCK_LOG("SendUninhibit(): XScreenSaver");
+    return InhibitXScreenSaver(false);
+  }
+#  endif
+#  if defined(MOZ_WAYLAND)
+  else if (mDesktopEnvironment == WaylandIdleInhibit) {
+    WAKE_LOCK_LOG("SendUninhibit(): Wayland");
+    return UninhibitWaylandIdle();
+  }
+#  endif
+
+  if (!message) {
+    return false;
+  }
+
+  dbus_message_append_args(message, DBUS_TYPE_UINT32, &mInhibitRequest,
+                           DBUS_TYPE_INVALID);
+
+  dbus_connection_send(mConnection, message, nullptr);
+  dbus_connection_flush(mConnection);
+
+  mInhibitRequest = 0;
+
+  return true;
+}
+
+nsresult WakeLockTopic::InhibitScreensaver() {
+  if (mShouldInhibit) {
+    // Screensaver is inhibited. Nothing to do here.
+    return NS_OK;
+  }
+
+  mShouldInhibit = true;
+
+  if (mWaitingForReply) {
+    // We already have a screensaver inhibit request pending. This can happen
+    // if InhibitScreensaver is called, then UninhibitScreensaver, then
+    // InhibitScreensaver again quickly.
+    return NS_OK;
+  }
+
+  return SendInhibit() ? NS_OK : NS_ERROR_FAILURE;
+}
+
+nsresult WakeLockTopic::UninhibitScreensaver() {
+  if (!mShouldInhibit) {
+    // Screensaver isn't inhibited. Nothing to do here.
+    return NS_OK;
+  }
+
+  mShouldInhibit = false;
+
+  if (mWaitingForReply) {
+    // If we're still waiting for a response to our inhibit request, we can't
+    // do anything until we get a dbus message back. The callbacks below will
+    // check |mShouldInhibit| and act accordingly.
+    return NS_OK;
+  }
+
+  return SendUninhibit() ? NS_OK : NS_ERROR_FAILURE;
+}
+
+void WakeLockTopic::InhibitFailed() {
+  mWaitingForReply = false;
+
+  if (mDesktopEnvironment == FreeDesktopScreensaver) {
+    mDesktopEnvironment = GNOME;
+  } else if (mDesktopEnvironment == GNOME) {
+    mDesktopEnvironment = FreeDesktopPower;
+#  if defined(MOZ_X11)
+  } else if (mDesktopEnvironment == FreeDesktopPower &&
+             CheckXScreenSaverSupport()) {
+    mDesktopEnvironment = XScreenSaver;
+#  endif
+#  if defined(MOZ_WAYLAND)
+  } else if (mDesktopEnvironment == FreeDesktopPower &&
+             CheckWaylandIdleInhibitSupport()) {
+    mDesktopEnvironment = WaylandIdleInhibit;
+#  endif
+  } else {
+    mDesktopEnvironment = Unsupported;
+    mShouldInhibit = false;
+  }
+
+  if (!mShouldInhibit) {
+    // We were interrupted by UninhibitScreensaver() before we could find the
+    // correct desktop environment.
+    return;
+  }
+
+  SendInhibit();
+}
+
+void WakeLockTopic::InhibitSucceeded(uint32_t aInhibitRequest) {
+  mWaitingForReply = false;
+  mInhibitRequest = aInhibitRequest;
+
+  if (!mShouldInhibit) {
+    // We successfully inhibited the screensaver, but UninhibitScreensaver()
+    // was called while we were waiting for a reply.
+    SendUninhibit();
+  }
+}
+
+/* static */
+void WakeLockTopic::ReceiveInhibitReply(DBusPendingCall* pending,
+                                        void* user_data) {
+  if (!WakeLockListener::GetSingleton(false)) {
+    // The WakeLockListener (and therefore our topic) was deleted while we were
+    // waiting for a reply.
+    return;
+  }
+
+  WakeLockTopic* self = static_cast<WakeLockTopic*>(user_data);
+
+  RefPtr<DBusMessage> msg =
+      already_AddRefed<DBusMessage>(dbus_pending_call_steal_reply(pending));
+  if (!msg) {
+    return;
+  }
+
+  if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
+    uint32_t inhibitRequest;
+
+    if (dbus_message_get_args(msg, nullptr, DBUS_TYPE_UINT32, &inhibitRequest,
+                              DBUS_TYPE_INVALID)) {
+      self->InhibitSucceeded(inhibitRequest);
+    }
+  } else {
+    self->InhibitFailed();
+  }
+}
+
+WakeLockListener::WakeLockListener() : mConnection(nullptr) {}
+
+/* static */
+WakeLockListener* WakeLockListener::GetSingleton(bool aCreate) {
+  if (!sSingleton && aCreate) {
+    sSingleton = new WakeLockListener();
+  }
+
+  return sSingleton;
+}
+
+/* static */
+void WakeLockListener::Shutdown() { sSingleton = nullptr; }
+
+bool WakeLockListener::EnsureDBusConnection() {
+  if (!mConnection) {
+    mConnection = already_AddRefed<DBusConnection>(
+        dbus_bus_get(DBUS_BUS_SESSION, nullptr));
+
+    if (mConnection) {
+      dbus_connection_set_exit_on_disconnect(mConnection, false);
+      dbus_connection_setup_with_g_main(mConnection, nullptr);
+    }
+  }
+
+  return mConnection != nullptr;
+}
+
+nsresult WakeLockListener::Callback(const nsAString& topic,
+                                    const nsAString& state) {
+  if (!EnsureDBusConnection()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  WAKE_LOCK_LOG("WakeLockListener %s state %s",
+                NS_ConvertUTF16toUTF8(topic).get(),
+                NS_ConvertUTF16toUTF8(state).get());
+
+  if (!topic.Equals(u"screen"_ns) && !topic.Equals(u"video-playing"_ns) &&
+      !topic.Equals(u"autoscroll"_ns))
+    return NS_OK;
+
+  WakeLockTopic* const topicLock =
+      mTopics.GetOrInsertNew(topic, topic, mConnection);
+
+  // Treat "locked-background" the same as "unlocked" on desktop linux.
+  bool shouldLock = state.EqualsLiteral("locked-foreground");
+  WAKE_LOCK_LOG("shouldLock %d", shouldLock);
+
+  return shouldLock ? topicLock->InhibitScreensaver()
+                    : topicLock->UninhibitScreensaver();
+}
+
+#endif
diff --git a/widget/gtk/WakeLockListener.h b/widget/gtk/WakeLockListener.h
new file mode 100644
index 0000000000..4f163434df
--- /dev/null
+++ b/widget/gtk/WakeLockListener.h
@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __WakeLockListener_h__
+#define __WakeLockListener_h__
+
+#include <unistd.h>
+
+#include "mozilla/StaticPtr.h"
+#include "nsHashKeys.h"
+#include "nsClassHashtable.h"
+
+#include "nsIDOMWakeLockListener.h"
+
+#ifdef MOZ_ENABLE_DBUS
+#  include "mozilla/DBusHelpers.h"
+#endif
+
+class WakeLockTopic;
+
+/**
+ * Receives WakeLock events and simply passes it on to the right WakeLockTopic
+ * to inhibit the screensaver.
+ */
+class WakeLockListener final : public nsIDOMMozWakeLockListener {
+ public:
+  NS_DECL_ISUPPORTS;
+
+  static WakeLockListener* GetSingleton(bool aCreate = true);
+  static void Shutdown();
+
+  virtual nsresult Callback(const nsAString& topic,
+                            const nsAString& state) override;
+
+ private:
+  WakeLockListener();
+  ~WakeLockListener() = default;
+
+  bool EnsureDBusConnection();
+
+  static mozilla::StaticRefPtr<WakeLockListener> sSingleton;
+
+#ifdef MOZ_ENABLE_DBUS
+  RefPtr<DBusConnection> mConnection;
+#endif
+  // Map of topic names to |WakeLockTopic|s.
+  // We assume a small, finite-sized set of topics.
+  nsClassHashtable<nsStringHashKey, WakeLockTopic> mTopics;
+};
+
+#endif  // __WakeLockListener_h__
diff --git a/widget/gtk/WaylandBuffer.cpp b/widget/gtk/WaylandBuffer.cpp
new file mode 100644
index 0000000000..d92d0666db
--- /dev/null
+++ b/widget/gtk/WaylandBuffer.cpp
@@ -0,0 +1,297 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WaylandBuffer.h"
+
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "gfx2DGlue.h"
+#include "gfxPlatform.h"
+#include "mozilla/WidgetUtilsGtk.h"
+#include "mozilla/gfx/Tools.h"
+#include "nsGtkUtils.h"
+#include "nsPrintfCString.h"
+#include "prenv.h"  // For PR_GetEnv
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "mozilla/ScopeExit.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gWidgetWaylandLog;
+#  define LOGWAYLAND(...) \
+    MOZ_LOG(gWidgetWaylandLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#else
+#  define LOGWAYLAND(...)
+#endif /* MOZ_LOGGING */
+
+using namespace mozilla::gl;
+
+namespace mozilla::widget {
+
+#define BUFFER_BPP 4
+gfx::SurfaceFormat WaylandBuffer::mFormat = gfx::SurfaceFormat::B8G8R8A8;
+
+#ifdef MOZ_LOGGING
+int WaylandBufferSHM::mDumpSerial =
+    PR_GetEnv("MOZ_WAYLAND_DUMP_WL_BUFFERS") ? 1 : 0;
+char* WaylandBufferSHM::mDumpDir = PR_GetEnv("MOZ_WAYLAND_DUMP_DIR");
+#endif
+
+static int WaylandAllocateShmMemory(int aSize) {
+  int fd = -1;
+
+  nsAutoCString shmPrefix("/");
+  if (const char* snapName = GetSnapInstanceName()) {
+    shmPrefix.AppendPrintf("snap.%s.", snapName);
+  }
+  shmPrefix.Append("wayland.mozilla.ipc");
+
+  do {
+    static int counter = 0;
+    nsPrintfCString shmName("%s.%d", shmPrefix.get(), counter++);
+    fd = shm_open(shmName.get(), O_CREAT | O_RDWR | O_EXCL, 0600);
+    if (fd >= 0) {
+      // We don't want to use leaked file
+      if (shm_unlink(shmName.get()) != 0) {
+        NS_WARNING("shm_unlink failed");
+        return -1;
+      }
+    }
+  } while (fd < 0 && errno == EEXIST);
+
+  if (fd < 0) {
+    NS_WARNING(nsPrintfCString("shm_open failed: %s", strerror(errno)).get());
+    return -1;
+  }
+
+  int ret = 0;
+#ifdef HAVE_POSIX_FALLOCATE
+  do {
+    ret = posix_fallocate(fd, 0, aSize);
+  } while (ret == EINTR);
+  if (ret == 0) {
+    return fd;
+  }
+  if (ret != ENODEV && ret != EINVAL && ret != EOPNOTSUPP) {
+    NS_WARNING(
+        nsPrintfCString("posix_fallocate() fails to allocate shm memory: %s",
+                        strerror(ret))
+            .get());
+    close(fd);
+    return -1;
+  }
+#endif
+  do {
+    ret = ftruncate(fd, aSize);
+  } while (ret < 0 && errno == EINTR);
+  if (ret < 0) {
+    NS_WARNING(nsPrintfCString("ftruncate() fails to allocate shm memory: %s",
+                               strerror(ret))
+                   .get());
+    close(fd);
+    fd = -1;
+  }
+
+  return fd;
+}
+
+/* static */
+RefPtr<WaylandShmPool> WaylandShmPool::Create(
+    const RefPtr<nsWaylandDisplay>& aWaylandDisplay, int aSize) {
+  if (!aWaylandDisplay->GetShm()) {
+    NS_WARNING("Missing Wayland shm interface!");
+    return nullptr;
+  }
+
+  RefPtr<WaylandShmPool> shmPool = new WaylandShmPool(aSize);
+
+  shmPool->mShmPoolFd = WaylandAllocateShmMemory(aSize);
+  if (shmPool->mShmPoolFd < 0) {
+    return nullptr;
+  }
+
+  shmPool->mImageData = mmap(nullptr, aSize, PROT_READ | PROT_WRITE, MAP_SHARED,
+                             shmPool->mShmPoolFd, 0);
+  if (shmPool->mImageData == MAP_FAILED) {
+    NS_WARNING("Unable to map drawing surface!");
+    return nullptr;
+  }
+
+  shmPool->mShmPool =
+      wl_shm_create_pool(aWaylandDisplay->GetShm(), shmPool->mShmPoolFd, aSize);
+  if (!shmPool->mShmPool) {
+    return nullptr;
+  }
+
+  // We set our queue to get mShmPool events at compositor thread.
+  wl_proxy_set_queue((struct wl_proxy*)shmPool->mShmPool,
+                     aWaylandDisplay->GetEventQueue());
+
+  return shmPool;
+}
+
+WaylandShmPool::WaylandShmPool(int aSize)
+    : mShmPool(nullptr),
+      mShmPoolFd(-1),
+      mAllocatedSize(aSize),
+      mImageData(nullptr){};
+
+WaylandShmPool::~WaylandShmPool() {
+  if (mImageData != MAP_FAILED) {
+    munmap(mImageData, mAllocatedSize);
+    mImageData = MAP_FAILED;
+  }
+  MozClearPointer(mShmPool, wl_shm_pool_destroy);
+  if (mShmPoolFd >= 0) {
+    close(mShmPoolFd);
+    mShmPoolFd = -1;
+  }
+}
+
+static const struct wl_buffer_listener sBufferListenerWaylandBuffer = {
+    WaylandBuffer::BufferReleaseCallbackHandler};
+
+WaylandBuffer::WaylandBuffer(const LayoutDeviceIntSize& aSize) : mSize(aSize) {}
+
+void WaylandBuffer::AttachAndCommit(wl_surface* aSurface) {
+  LOGWAYLAND(
+      "WaylandBuffer::AttachAndCommit [%p] wl_surface %p ID %d wl_buffer "
+      "%p ID %d\n",
+      (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_buffer* buffer = GetWlBuffer();
+  if (buffer) {
+    mAttached = true;
+    wl_surface_attach(aSurface, buffer, 0, 0);
+    wl_surface_commit(aSurface);
+  }
+}
+
+void WaylandBuffer::BufferReleaseCallbackHandler(wl_buffer* aBuffer) {
+  mAttached = false;
+
+  if (mBufferReleaseFunc) {
+    mBufferReleaseFunc(mBufferReleaseData, aBuffer);
+  }
+}
+
+void WaylandBuffer::BufferReleaseCallbackHandler(void* aData,
+                                                 wl_buffer* aBuffer) {
+  auto* buffer = reinterpret_cast<WaylandBuffer*>(aData);
+  buffer->BufferReleaseCallbackHandler(aBuffer);
+}
+
+/* static */
+RefPtr<WaylandBufferSHM> WaylandBufferSHM::Create(
+    const LayoutDeviceIntSize& aSize) {
+  RefPtr<WaylandBufferSHM> buffer = new WaylandBufferSHM(aSize);
+  RefPtr<nsWaylandDisplay> waylandDisplay = WaylandDisplayGet();
+
+  int size = aSize.width * aSize.height * BUFFER_BPP;
+  buffer->mShmPool = WaylandShmPool::Create(waylandDisplay, size);
+  if (!buffer->mShmPool) {
+    return nullptr;
+  }
+
+  buffer->mWLBuffer = wl_shm_pool_create_buffer(
+      buffer->mShmPool->GetShmPool(), 0, aSize.width, aSize.height,
+      aSize.width * BUFFER_BPP, WL_SHM_FORMAT_ARGB8888);
+  if (!buffer->mWLBuffer) {
+    return nullptr;
+  }
+
+  wl_proxy_set_queue((struct wl_proxy*)buffer->GetWlBuffer(),
+                     waylandDisplay->GetEventQueue());
+  wl_buffer_add_listener(buffer->GetWlBuffer(), &sBufferListenerWaylandBuffer,
+                         buffer.get());
+
+  LOGWAYLAND("WaylandBufferSHM Created [%p] WaylandDisplay [%p]\n",
+             buffer.get(), waylandDisplay.get());
+
+  return buffer;
+}
+
+WaylandBufferSHM::WaylandBufferSHM(const LayoutDeviceIntSize& aSize)
+    : WaylandBuffer(aSize) {}
+
+WaylandBufferSHM::~WaylandBufferSHM() {
+  MozClearPointer(mWLBuffer, wl_buffer_destroy);
+}
+
+already_AddRefed<gfx::DrawTarget> WaylandBufferSHM::Lock() {
+  return gfxPlatform::CreateDrawTargetForData(
+      static_cast<unsigned char*>(mShmPool->GetImageData()),
+      mSize.ToUnknownSize(), BUFFER_BPP * mSize.width, GetSurfaceFormat());
+}
+
+void WaylandBufferSHM::Clear() {
+  memset(mShmPool->GetImageData(), 0, mSize.height * mSize.width * BUFFER_BPP);
+}
+
+#ifdef MOZ_LOGGING
+void WaylandBufferSHM::DumpToFile(const char* aHint) {
+  if (!mDumpSerial) {
+    return;
+  }
+
+  cairo_surface_t* surface = nullptr;
+  auto unmap = MakeScopeExit([&] {
+    if (surface) {
+      cairo_surface_destroy(surface);
+    }
+  });
+  surface = cairo_image_surface_create_for_data(
+      (unsigned char*)mShmPool->GetImageData(), CAIRO_FORMAT_ARGB32,
+      mSize.width, mSize.height, BUFFER_BPP * mSize.width);
+  if (cairo_surface_status(surface) == CAIRO_STATUS_SUCCESS) {
+    nsCString filename;
+    if (mDumpDir) {
+      filename.Append(mDumpDir);
+      filename.Append('/');
+    }
+    filename.Append(
+        nsPrintfCString("firefox-wl-buffer-%.5d-%s.png", mDumpSerial++, aHint));
+    cairo_surface_write_to_png(surface, filename.get());
+    LOGWAYLAND("Dumped wl_buffer to %s\n", filename.get());
+  }
+}
+#endif
+
+/* static */
+RefPtr<WaylandBufferDMABUF> WaylandBufferDMABUF::Create(
+    const LayoutDeviceIntSize& aSize, GLContext* aGL) {
+  RefPtr<WaylandBufferDMABUF> buffer = new WaylandBufferDMABUF(aSize);
+
+  const auto flags =
+      static_cast<DMABufSurfaceFlags>(DMABUF_TEXTURE | DMABUF_ALPHA);
+  buffer->mDMABufSurface =
+      DMABufSurfaceRGBA::CreateDMABufSurface(aSize.width, aSize.height, flags);
+  if (!buffer->mDMABufSurface || !buffer->mDMABufSurface->CreateTexture(aGL)) {
+    return nullptr;
+  }
+
+  if (!buffer->mDMABufSurface->CreateWlBuffer()) {
+    return nullptr;
+  }
+
+  RefPtr<nsWaylandDisplay> waylandDisplay = WaylandDisplayGet();
+  wl_proxy_set_queue((struct wl_proxy*)buffer->GetWlBuffer(),
+                     waylandDisplay->GetEventQueue());
+  wl_buffer_add_listener(buffer->GetWlBuffer(), &sBufferListenerWaylandBuffer,
+                         buffer.get());
+
+  return buffer;
+}
+
+WaylandBufferDMABUF::WaylandBufferDMABUF(const LayoutDeviceIntSize& aSize)
+    : WaylandBuffer(aSize) {}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/WaylandBuffer.h b/widget/gtk/WaylandBuffer.h
new file mode 100644
index 0000000000..7101c53771
--- /dev/null
+++ b/widget/gtk/WaylandBuffer.h
@@ -0,0 +1,139 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_GTK_WAYLAND_BUFFER_H
+#define _MOZILLA_WIDGET_GTK_WAYLAND_BUFFER_H
+
+#include "DMABufSurface.h"
+#include "GLContext.h"
+#include "MozFramebuffer.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/Mutex.h"
+#include "nsTArray.h"
+#include "nsWaylandDisplay.h"
+
+namespace mozilla::widget {
+
+// Allocates and owns shared memory for Wayland drawing surface
+class WaylandShmPool {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WaylandShmPool);
+
+  static RefPtr<WaylandShmPool> Create(
+      const RefPtr<nsWaylandDisplay>& aWaylandDisplay, int aSize);
+
+  wl_shm_pool* GetShmPool() { return mShmPool; };
+  void* GetImageData() { return mImageData; };
+
+ private:
+  explicit WaylandShmPool(int aSize);
+  ~WaylandShmPool();
+
+  wl_shm_pool* mShmPool;
+  int mShmPoolFd;
+  int mAllocatedSize;
+  void* mImageData;
+};
+
+class WaylandBuffer {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WaylandBuffer);
+
+  void AttachAndCommit(wl_surface* aSurface);
+  virtual wl_buffer* GetWlBuffer() = 0;
+  virtual already_AddRefed<gfx::DrawTarget> Lock() { return nullptr; };
+  virtual void* GetImageData() { return nullptr; }
+  virtual GLuint GetTexture() { return 0; }
+  virtual void DestroyGLResources(){};
+
+  LayoutDeviceIntSize GetSize() { return mSize; };
+  bool IsMatchingSize(const LayoutDeviceIntSize& aSize) {
+    return aSize == mSize;
+  }
+  bool IsAttached() { return mAttached; }
+  static gfx::SurfaceFormat GetSurfaceFormat() { return mFormat; }
+
+  static void BufferReleaseCallbackHandler(void* aData, wl_buffer* aBuffer);
+  void SetBufferReleaseFunc(void (*aBufferReleaseFunc)(void* aData,
+                                                       wl_buffer* aBuffer)) {
+    mBufferReleaseFunc = aBufferReleaseFunc;
+  }
+  void SetBufferReleaseData(void* aBufferReleaseData) {
+    mBufferReleaseData = aBufferReleaseData;
+  }
+
+ protected:
+  explicit WaylandBuffer(const LayoutDeviceIntSize& aSize);
+  virtual ~WaylandBuffer() = default;
+
+  void BufferReleaseCallbackHandler(wl_buffer* aBuffer);
+
+  LayoutDeviceIntSize mSize;
+  bool mAttached = false;
+  void (*mBufferReleaseFunc)(void* aData, wl_buffer* aBuffer) = nullptr;
+  void* mBufferReleaseData = nullptr;
+  static gfx::SurfaceFormat mFormat;
+};
+
+// Holds actual graphics data for wl_surface
+class WaylandBufferSHM final : public WaylandBuffer {
+ public:
+  static RefPtr<WaylandBufferSHM> Create(const LayoutDeviceIntSize& aSize);
+
+  wl_buffer* GetWlBuffer() override { return mWLBuffer; };
+  already_AddRefed<gfx::DrawTarget> Lock() override;
+  void* GetImageData() override { return mShmPool->GetImageData(); }
+
+  void Clear();
+  size_t GetBufferAge() { return mBufferAge; };
+  RefPtr<WaylandShmPool> GetShmPool() { return mShmPool; }
+
+  void IncrementBufferAge() { mBufferAge++; };
+  void ResetBufferAge() { mBufferAge = 0; };
+
+#ifdef MOZ_LOGGING
+  void DumpToFile(const char* aHint);
+#endif
+
+ private:
+  explicit WaylandBufferSHM(const LayoutDeviceIntSize& aSize);
+  ~WaylandBufferSHM() override;
+
+  // WaylandShmPoolMB provides actual shared memory we draw into
+  RefPtr<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* mWLBuffer = nullptr;
+
+  size_t mBufferAge = 0;
+
+#ifdef MOZ_LOGGING
+  static int mDumpSerial;
+  static char* mDumpDir;
+#endif
+};
+
+class WaylandBufferDMABUF final : public WaylandBuffer {
+ public:
+  static RefPtr<WaylandBufferDMABUF> Create(const LayoutDeviceIntSize& aSize,
+                                            gl::GLContext* aGL);
+
+  wl_buffer* GetWlBuffer() override { return mDMABufSurface->GetWlBuffer(); };
+  GLuint GetTexture() override { return mDMABufSurface->GetTexture(); };
+  void DestroyGLResources() override { mDMABufSurface->ReleaseTextures(); };
+
+ private:
+  explicit WaylandBufferDMABUF(const LayoutDeviceIntSize& aSize);
+  ~WaylandBufferDMABUF() = default;
+
+  RefPtr<DMABufSurfaceRGBA> mDMABufSurface;
+};
+
+}  // namespace mozilla::widget
+
+#endif  // _MOZILLA_WIDGET_GTK_WAYLAND_BUFFER_H
diff --git a/widget/gtk/WaylandVsyncSource.cpp b/widget/gtk/WaylandVsyncSource.cpp
new file mode 100644
index 0000000000..44174c9640
--- /dev/null
+++ b/widget/gtk/WaylandVsyncSource.cpp
@@ -0,0 +1,422 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifdef MOZ_WAYLAND
+
+#  include "WaylandVsyncSource.h"
+#  include "mozilla/UniquePtr.h"
+#  include "nsThreadUtils.h"
+#  include "nsISupportsImpl.h"
+#  include "MainThreadUtils.h"
+#  include "mozilla/ScopeExit.h"
+#  include "nsGtkUtils.h"
+#  include "mozilla/StaticPrefs_layout.h"
+#  include "nsWindow.h"
+
+#  include <gdk/gdkwayland.h>
+
+#  ifdef MOZ_LOGGING
+#    include "mozilla/Logging.h"
+#    include "nsTArray.h"
+#    include "Units.h"
+extern mozilla::LazyLogModule gWidgetVsync;
+#    undef LOG
+#    define LOG(str, ...)                             \
+      MOZ_LOG(gWidgetVsync, mozilla::LogLevel::Debug, \
+              ("[nsWindow %p]: " str, GetWindowForLogging(), ##__VA_ARGS__))
+#  else
+#    define LOG(...)
+#  endif /* MOZ_LOGGING */
+
+using namespace mozilla::widget;
+
+namespace mozilla {
+
+static void WaylandVsyncSourceCallbackHandler(void* aData,
+                                              struct wl_callback* aCallback,
+                                              uint32_t aTime) {
+  RefPtr<WaylandVsyncSource> context(static_cast<WaylandVsyncSource*>(aData));
+  context->FrameCallback(aCallback, aTime);
+}
+
+static const struct wl_callback_listener WaylandVsyncSourceCallbackListener = {
+    WaylandVsyncSourceCallbackHandler};
+
+static void NativeLayerRootWaylandVsyncCallback(void* aData, uint32_t aTime) {
+  RefPtr<WaylandVsyncSource> context(static_cast<WaylandVsyncSource*>(aData));
+  context->FrameCallback(nullptr, aTime);
+}
+
+static float GetFPS(TimeDuration aVsyncRate) {
+  return 1000.0 / aVsyncRate.ToMilliseconds();
+}
+
+static nsTArray<WaylandVsyncSource*> gWaylandVsyncSources;
+
+Maybe<TimeDuration> WaylandVsyncSource::GetFastestVsyncRate() {
+  Maybe<TimeDuration> retVal;
+  for (auto* source : gWaylandVsyncSources) {
+    auto rate = source->GetVsyncRateIfEnabled();
+    if (!rate) {
+      continue;
+    }
+    if (!retVal.isSome()) {
+      retVal.emplace(*rate);
+    } else if (*rate < *retVal) {
+      retVal.ref() = *rate;
+    }
+  }
+
+  return retVal;
+}
+
+WaylandVsyncSource::WaylandVsyncSource(nsWindow* aWindow)
+    : mMutex("WaylandVsyncSource"),
+      mVsyncRate(TimeDuration::FromMilliseconds(1000.0 / 60.0)),
+      mLastVsyncTimeStamp(TimeStamp::Now()),
+      mWindow(aWindow),
+      mIdleTimeout(1000 / StaticPrefs::layout_throttled_frame_rate()) {
+  MOZ_ASSERT(NS_IsMainThread());
+  gWaylandVsyncSources.AppendElement(this);
+}
+
+WaylandVsyncSource::~WaylandVsyncSource() {
+  gWaylandVsyncSources.RemoveElement(this);
+}
+
+void WaylandVsyncSource::MaybeUpdateSource(MozContainer* aContainer) {
+  MutexAutoLock lock(mMutex);
+
+  LOG("WaylandVsyncSource::MaybeUpdateSource fps %f", GetFPS(mVsyncRate));
+
+  if (aContainer == mContainer) {
+    LOG("  mContainer is the same, quit.");
+    return;
+  }
+
+  mNativeLayerRoot = nullptr;
+  mContainer = aContainer;
+
+  if (mMonitorEnabled) {
+    LOG("  monitor enabled, ask for Refresh()");
+    mCallbackRequested = false;
+    Refresh(lock);
+  }
+}
+
+void WaylandVsyncSource::MaybeUpdateSource(
+    const RefPtr<NativeLayerRootWayland>& aNativeLayerRoot) {
+  MutexAutoLock lock(mMutex);
+
+  LOG("WaylandVsyncSource::MaybeUpdateSource aNativeLayerRoot fps %f",
+      GetFPS(mVsyncRate));
+
+  if (aNativeLayerRoot == mNativeLayerRoot) {
+    LOG("  mNativeLayerRoot is the same, quit.");
+    return;
+  }
+
+  mNativeLayerRoot = aNativeLayerRoot;
+  mContainer = nullptr;
+
+  if (mMonitorEnabled) {
+    LOG("  monitor enabled, ask for Refresh()");
+    mCallbackRequested = false;
+    Refresh(lock);
+  }
+}
+
+void WaylandVsyncSource::Refresh(const MutexAutoLock& aProofOfLock) {
+  mMutex.AssertCurrentThreadOwns();
+
+  LOG("WaylandVsyncSource::Refresh fps %f\n", GetFPS(mVsyncRate));
+
+  if (!(mContainer || mNativeLayerRoot) || !mMonitorEnabled || !mVsyncEnabled ||
+      mCallbackRequested) {
+    // We don't need to do anything because:
+    // * We are unwanted by our widget or monitor, or
+    // * The last frame callback hasn't yet run to see that it had been shut
+    //   down, so we can reuse it after having set mVsyncEnabled to true.
+    LOG("  quit mContainer %d mNativeLayerRoot %d mMonitorEnabled %d "
+        "mVsyncEnabled %d mCallbackRequested %d",
+        !!mContainer, !!mNativeLayerRoot, mMonitorEnabled, mVsyncEnabled,
+        !!mCallbackRequested);
+    return;
+  }
+
+  if (mContainer) {
+    MozContainerSurfaceLock lock(mContainer);
+    struct wl_surface* surface = lock.GetSurface();
+    LOG("  refresh from mContainer, wl_surface %p", surface);
+    if (!surface) {
+      LOG("  we're missing wl_surface, register Refresh() callback");
+      // The surface hasn't been created yet. Try again when the surface is
+      // ready.
+      RefPtr<WaylandVsyncSource> self(this);
+      moz_container_wayland_add_initial_draw_callback_locked(
+          mContainer, [self]() -> void {
+            MutexAutoLock lock(self->mMutex);
+            self->Refresh(lock);
+          });
+      return;
+    }
+  }
+
+  // Vsync is enabled, but we don't have a callback configured. Set one up so
+  // we can get to work.
+  SetupFrameCallback(aProofOfLock);
+  const TimeStamp lastVSync = TimeStamp::Now();
+  mLastVsyncTimeStamp = lastVSync;
+  TimeStamp outputTimestamp = mLastVsyncTimeStamp + mVsyncRate;
+
+  {
+    MutexAutoUnlock unlock(mMutex);
+    NotifyVsync(lastVSync, outputTimestamp);
+  }
+}
+
+void WaylandVsyncSource::EnableMonitor() {
+  LOG("WaylandVsyncSource::EnableMonitor");
+  MutexAutoLock lock(mMutex);
+  if (mMonitorEnabled) {
+    return;
+  }
+  mMonitorEnabled = true;
+  Refresh(lock);
+}
+
+void WaylandVsyncSource::DisableMonitor() {
+  LOG("WaylandVsyncSource::DisableMonitor");
+  MutexAutoLock lock(mMutex);
+  if (!mMonitorEnabled) {
+    return;
+  }
+  mMonitorEnabled = false;
+  mCallbackRequested = false;
+}
+
+void WaylandVsyncSource::SetupFrameCallback(const MutexAutoLock& aProofOfLock) {
+  mMutex.AssertCurrentThreadOwns();
+  MOZ_ASSERT(!mCallbackRequested);
+
+  LOG("WaylandVsyncSource::SetupFrameCallback");
+
+  if (mNativeLayerRoot) {
+    LOG("  use mNativeLayerRoot");
+    mNativeLayerRoot->RequestFrameCallback(&NativeLayerRootWaylandVsyncCallback,
+                                           this);
+  } else {
+    MozContainerSurfaceLock lock(mContainer);
+    struct wl_surface* surface = lock.GetSurface();
+    LOG("  use mContainer, wl_surface %p", surface);
+    if (!surface) {
+      // We don't have a surface, either due to being called before it was made
+      // available in the mozcontainer, or after it was destroyed. We're all
+      // done regardless.
+      LOG("  missing wl_surface, quit.");
+      return;
+    }
+
+    LOG("  register frame callback");
+    MozClearPointer(mCallback, wl_callback_destroy);
+    mCallback = wl_surface_frame(surface);
+    wl_callback_add_listener(mCallback, &WaylandVsyncSourceCallbackListener,
+                             this);
+    wl_surface_commit(surface);
+    wl_display_flush(WaylandDisplayGet()->GetDisplay());
+
+    if (!mIdleTimerID) {
+      mIdleTimerID = (int)g_timeout_add(
+          mIdleTimeout,
+          [](void* data) -> gint {
+            auto* vsync = static_cast<WaylandVsyncSource*>(data);
+            vsync->IdleCallback();
+            return true;
+          },
+          this);
+    }
+  }
+
+  mCallbackRequested = true;
+}
+
+void WaylandVsyncSource::IdleCallback() {
+  LOG("WaylandVsyncSource::IdleCallback");
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+
+  RefPtr<nsWindow> window;
+  TimeStamp lastVSync;
+  TimeStamp outputTimestamp;
+  {
+    MutexAutoLock lock(mMutex);
+
+    if (!mVsyncEnabled || !mMonitorEnabled) {
+      // We are unwanted by either our creator or our consumer, so we just stop
+      // here without setting up a new frame callback.
+      LOG("  quit, mVsyncEnabled %d mMonitorEnabled %d", mVsyncEnabled,
+          mMonitorEnabled);
+      return;
+    }
+
+    guint duration = static_cast<guint>(
+        (TimeStamp::Now() - mLastVsyncTimeStamp).ToMilliseconds());
+    if (duration < mIdleTimeout) {
+      return;
+    }
+
+    LOG("  fire idle vsync");
+    CalculateVsyncRate(lock, TimeStamp::Now());
+    mLastVsyncTimeStamp = TimeStamp::Now();
+
+    lastVSync = mLastVsyncTimeStamp;
+    outputTimestamp = mLastVsyncTimeStamp + mVsyncRate;
+    window = mWindow;
+  }
+
+  // This could disable vsync.
+  window->NotifyOcclusionState(OcclusionState::OCCLUDED);
+
+  // Make sure to fire vsync now even if we get disabled afterwards.
+  // This gives an opportunity to clean up after the visibility state change.
+  if (!window->IsDestroyed()) {
+    NotifyVsync(lastVSync, outputTimestamp);
+  }
+}
+
+void WaylandVsyncSource::FrameCallback(wl_callback* aCallback, uint32_t aTime) {
+  LOG("WaylandVsyncSource::FrameCallback");
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+
+  {
+    // This might enable vsync.
+    RefPtr window = mWindow;
+    window->NotifyOcclusionState(OcclusionState::VISIBLE);
+    // NotifyOcclusionState can destroy us.
+    if (window->IsDestroyed()) {
+      return;
+    }
+  }
+
+  MutexAutoLock lock(mMutex);
+  mCallbackRequested = false;
+
+  // NotifyOcclusionState() can clear and create new mCallback by
+  // EnableVsync()/Refresh(). So don't delete newly created frame callback.
+  if (aCallback && aCallback == mCallback) {
+    MozClearPointer(mCallback, wl_callback_destroy);
+  }
+
+  if (!mVsyncEnabled || !mMonitorEnabled) {
+    // We are unwanted by either our creator or our consumer, so we just stop
+    // here without setting up a new frame callback.
+    LOG("  quit, mVsyncEnabled %d mMonitorEnabled %d", mVsyncEnabled,
+        mMonitorEnabled);
+    return;
+  }
+
+  // Configure our next frame callback.
+  SetupFrameCallback(lock);
+
+  int64_t tick = BaseTimeDurationPlatformUtils::TicksFromMilliseconds(aTime);
+  TimeStamp callbackTimeStamp = TimeStamp::FromSystemTime(tick);
+  double duration = (TimeStamp::Now() - callbackTimeStamp).ToMilliseconds();
+
+  TimeStamp vsyncTimestamp;
+  if (duration < 50 && duration > -50) {
+    vsyncTimestamp = callbackTimeStamp;
+  } else {
+    vsyncTimestamp = TimeStamp::Now();
+  }
+
+  CalculateVsyncRate(lock, vsyncTimestamp);
+  mLastVsyncTimeStamp = vsyncTimestamp;
+  TimeStamp outputTimestamp = vsyncTimestamp + mVsyncRate;
+
+  {
+    MutexAutoUnlock unlock(mMutex);
+    NotifyVsync(vsyncTimestamp, outputTimestamp);
+  }
+}
+
+TimeDuration WaylandVsyncSource::GetVsyncRate() {
+  MutexAutoLock lock(mMutex);
+  return mVsyncRate;
+}
+
+Maybe<TimeDuration> WaylandVsyncSource::GetVsyncRateIfEnabled() {
+  MutexAutoLock lock(mMutex);
+  if (!mVsyncEnabled) {
+    return Nothing();
+  }
+  return Some(mVsyncRate);
+}
+
+void WaylandVsyncSource::CalculateVsyncRate(const MutexAutoLock& aProofOfLock,
+                                            TimeStamp aVsyncTimestamp) {
+  mMutex.AssertCurrentThreadOwns();
+
+  double duration = (aVsyncTimestamp - mLastVsyncTimeStamp).ToMilliseconds();
+  double curVsyncRate = mVsyncRate.ToMilliseconds();
+
+  LOG("WaylandVsyncSource::CalculateVsyncRate start fps %f\n",
+      GetFPS(mVsyncRate));
+
+  double correction;
+  if (duration > curVsyncRate) {
+    correction = fmin(curVsyncRate, (duration - curVsyncRate) / 10);
+    mVsyncRate += TimeDuration::FromMilliseconds(correction);
+  } else {
+    correction = fmin(curVsyncRate / 2, (curVsyncRate - duration) / 10);
+    mVsyncRate -= TimeDuration::FromMilliseconds(correction);
+  }
+
+  LOG("  new fps %f correction %f\n", GetFPS(mVsyncRate), correction);
+}
+
+void WaylandVsyncSource::EnableVsync() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  MutexAutoLock lock(mMutex);
+
+  LOG("WaylandVsyncSource::EnableVsync fps %f\n", GetFPS(mVsyncRate));
+  if (mVsyncEnabled || mIsShutdown) {
+    LOG("  early quit");
+    return;
+  }
+  mVsyncEnabled = true;
+  Refresh(lock);
+}
+
+void WaylandVsyncSource::DisableVsync() {
+  MutexAutoLock lock(mMutex);
+
+  LOG("WaylandVsyncSource::DisableVsync fps %f\n", GetFPS(mVsyncRate));
+  mVsyncEnabled = false;
+  mCallbackRequested = false;
+}
+
+bool WaylandVsyncSource::IsVsyncEnabled() {
+  MutexAutoLock lock(mMutex);
+  return mVsyncEnabled;
+}
+
+void WaylandVsyncSource::Shutdown() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MutexAutoLock lock(mMutex);
+
+  LOG("WaylandVsyncSource::Shutdown fps %f\n", GetFPS(mVsyncRate));
+  mContainer = nullptr;
+  mNativeLayerRoot = nullptr;
+  mIsShutdown = true;
+  mVsyncEnabled = false;
+  mCallbackRequested = false;
+  MozClearHandleID(mIdleTimerID, g_source_remove);
+  MozClearPointer(mCallback, wl_callback_destroy);
+}
+
+}  // namespace mozilla
+
+#endif  // MOZ_WAYLAND
diff --git a/widget/gtk/WaylandVsyncSource.h b/widget/gtk/WaylandVsyncSource.h
new file mode 100644
index 0000000000..faed35021f
--- /dev/null
+++ b/widget/gtk/WaylandVsyncSource.h
@@ -0,0 +1,98 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _WaylandVsyncSource_h_
+#define _WaylandVsyncSource_h_
+
+#include "base/thread.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/layers/NativeLayerWayland.h"
+#include "MozContainer.h"
+#include "nsWaylandDisplay.h"
+#include "VsyncSource.h"
+
+namespace mozilla {
+
+using layers::NativeLayerRootWayland;
+
+/*
+ * WaylandVsyncSource
+ *
+ * This class provides a per-widget VsyncSource under Wayland, emulated using
+ * frame callbacks on the widget surface with empty surface commits.
+ *
+ * Wayland does not expose vsync/vblank, as it considers that an implementation
+ * detail the clients should not concern themselves with. Instead, frame
+ * callbacks are provided whenever the compositor believes it is a good time to
+ * start drawing the next frame for a particular surface, giving us as much
+ * time as possible to do so.
+ *
+ * Note that the compositor sends frame callbacks only when it sees fit, and
+ * when that may be is entirely up to the compositor. One cannot expect a
+ * certain rate of callbacks, or any callbacks at all. Examples of common
+ * variations would be surfaces moved between outputs with different refresh
+ * rates, and surfaces that are hidden and therefore do not receieve any
+ * callbacks at all. Other hypothetical scenarios of variation could be
+ * throttling to conserve power, or because a user has requested it.
+ *
+ */
+class WaylandVsyncSource final : public gfx::VsyncSource {
+ public:
+  explicit WaylandVsyncSource(nsWindow* aWindow);
+  virtual ~WaylandVsyncSource();
+
+  static Maybe<TimeDuration> GetFastestVsyncRate();
+
+  void MaybeUpdateSource(MozContainer* aContainer);
+  void MaybeUpdateSource(
+      const RefPtr<NativeLayerRootWayland>& aNativeLayerRoot);
+
+  void EnableMonitor();
+  void DisableMonitor();
+
+  void FrameCallback(wl_callback* aCallback, uint32_t aTime);
+  void IdleCallback();
+
+  TimeDuration GetVsyncRate() override;
+
+  void EnableVsync() override;
+
+  void DisableVsync() override;
+
+  bool IsVsyncEnabled() override;
+
+  void Shutdown() override;
+
+ private:
+  Maybe<TimeDuration> GetVsyncRateIfEnabled();
+
+  void Refresh(const MutexAutoLock& aProofOfLock);
+  void SetupFrameCallback(const MutexAutoLock& aProofOfLock);
+  void CalculateVsyncRate(const MutexAutoLock& aProofOfLock,
+                          TimeStamp aVsyncTimestamp);
+  void* GetWindowForLogging() { return mWindow; };
+
+  Mutex mMutex;
+  bool mIsShutdown MOZ_GUARDED_BY(mMutex) = false;
+  bool mVsyncEnabled MOZ_GUARDED_BY(mMutex) = false;
+  bool mMonitorEnabled MOZ_GUARDED_BY(mMutex) = false;
+  bool mCallbackRequested MOZ_GUARDED_BY(mMutex) = false;
+  MozContainer* mContainer MOZ_GUARDED_BY(mMutex) = nullptr;
+  RefPtr<NativeLayerRootWayland> mNativeLayerRoot MOZ_GUARDED_BY(mMutex);
+  TimeDuration mVsyncRate MOZ_GUARDED_BY(mMutex);
+  TimeStamp mLastVsyncTimeStamp MOZ_GUARDED_BY(mMutex);
+  guint mIdleTimerID MOZ_GUARDED_BY(mMutex) = 0;
+  wl_callback* mCallback MOZ_GUARDED_BY(mMutex) = nullptr;
+
+  nsWindow* const mWindow;  // Main thread only, except for logging.
+  const guint mIdleTimeout;
+};
+
+}  // namespace mozilla
+
+#endif  // _WaylandVsyncSource_h_
diff --git a/widget/gtk/WidgetStyleCache.cpp b/widget/gtk/WidgetStyleCache.cpp
new file mode 100644
index 0000000000..1b6287c876
--- /dev/null
+++ b/widget/gtk/WidgetStyleCache.cpp
@@ -0,0 +1,1516 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <dlfcn.h>
+#include <gtk/gtk.h>
+#include "WidgetStyleCache.h"
+#include "gtkdrawing.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/ScopeExit.h"
+#include "nsDebug.h"
+#include "nsPrintfCString.h"
+#include "nsString.h"
+
+#define STATE_FLAG_DIR_LTR (1U << 7)
+#define STATE_FLAG_DIR_RTL (1U << 8)
+static_assert(GTK_STATE_FLAG_DIR_LTR == STATE_FLAG_DIR_LTR &&
+                  GTK_STATE_FLAG_DIR_RTL == STATE_FLAG_DIR_RTL,
+              "incorrect direction state flags");
+
+enum class CSDStyle {
+  Unknown,
+  Solid,
+  Normal,
+};
+
+static bool gHeaderBarShouldDrawContainer = false;
+static bool gMaximizedHeaderBarShouldDrawContainer = false;
+static CSDStyle gCSDStyle = CSDStyle::Unknown;
+static GtkWidget* sWidgetStorage[MOZ_GTK_WIDGET_NODE_COUNT];
+static GtkStyleContext* sStyleStorage[MOZ_GTK_WIDGET_NODE_COUNT];
+
+static GtkStyleContext* GetWidgetRootStyle(WidgetNodeType aNodeType);
+static GtkStyleContext* GetCssNodeStyleInternal(WidgetNodeType aNodeType);
+
+static GtkWidget* CreateWindowWidget() {
+  GtkWidget* widget = gtk_window_new(GTK_WINDOW_POPUP);
+  MOZ_RELEASE_ASSERT(widget, "We're missing GtkWindow widget!");
+  gtk_widget_set_name(widget, "MozillaGtkWidget");
+  return widget;
+}
+
+static GtkWidget* CreateWindowContainerWidget() {
+  GtkWidget* widget = gtk_fixed_new();
+  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_WINDOW)), widget);
+  return widget;
+}
+
+static void AddToWindowContainer(GtkWidget* widget) {
+  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_WINDOW_CONTAINER)), widget);
+}
+
+static GtkWidget* CreateScrollbarWidget(WidgetNodeType aAppearance,
+                                        GtkOrientation aOrientation) {
+  GtkWidget* widget = gtk_scrollbar_new(aOrientation, nullptr);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateCheckboxWidget() {
+  GtkWidget* widget = gtk_check_button_new_with_label("M");
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateRadiobuttonWidget() {
+  GtkWidget* widget = gtk_radio_button_new_with_label(nullptr, "M");
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateMenuBarWidget() {
+  GtkWidget* widget = gtk_menu_bar_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateMenuPopupWidget() {
+  GtkWidget* widget = gtk_menu_new();
+  GtkStyleContext* style = gtk_widget_get_style_context(widget);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_POPUP);
+  gtk_menu_attach_to_widget(GTK_MENU(widget), GetWidget(MOZ_GTK_WINDOW),
+                            nullptr);
+  return widget;
+}
+
+static GtkWidget* CreateProgressWidget() {
+  GtkWidget* widget = gtk_progress_bar_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateTooltipWidget() {
+  MOZ_ASSERT(gtk_check_version(3, 20, 0) != nullptr,
+             "CreateTooltipWidget should be used for Gtk < 3.20 only.");
+  GtkWidget* widget = CreateWindowWidget();
+  GtkStyleContext* style = gtk_widget_get_style_context(widget);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);
+  return widget;
+}
+
+static GtkWidget* CreateExpanderWidget() {
+  GtkWidget* widget = gtk_expander_new("M");
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateFrameWidget() {
+  GtkWidget* widget = gtk_frame_new(nullptr);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateGripperWidget() {
+  GtkWidget* widget = gtk_handle_box_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateToolbarWidget() {
+  GtkWidget* widget = gtk_toolbar_new();
+  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_GRIPPER)), widget);
+  return widget;
+}
+
+static GtkWidget* CreateToolbarSeparatorWidget() {
+  GtkWidget* widget = GTK_WIDGET(gtk_separator_tool_item_new());
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateButtonWidget() {
+  GtkWidget* widget = gtk_button_new_with_label("M");
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateToggleButtonWidget() {
+  GtkWidget* widget = gtk_toggle_button_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateButtonArrowWidget() {
+  GtkWidget* widget = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_TOGGLE_BUTTON)), widget);
+  gtk_widget_show(widget);
+  return widget;
+}
+
+static GtkWidget* CreateSpinWidget() {
+  GtkWidget* widget = gtk_spin_button_new(nullptr, 1, 0);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateEntryWidget() {
+  GtkWidget* widget = gtk_entry_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateComboBoxWidget() {
+  GtkWidget* widget = gtk_combo_box_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+typedef struct {
+  GType type;
+  GtkWidget** widget;
+} GtkInnerWidgetInfo;
+
+static void GetInnerWidget(GtkWidget* widget, gpointer client_data) {
+  auto info = static_cast<GtkInnerWidgetInfo*>(client_data);
+
+  if (G_TYPE_CHECK_INSTANCE_TYPE(widget, info->type)) {
+    *info->widget = widget;
+  }
+}
+
+static GtkWidget* CreateComboBoxButtonWidget() {
+  GtkWidget* comboBox = GetWidget(MOZ_GTK_COMBOBOX);
+  GtkWidget* comboBoxButton = nullptr;
+
+  /* Get its inner Button */
+  GtkInnerWidgetInfo info = {GTK_TYPE_TOGGLE_BUTTON, &comboBoxButton};
+  gtk_container_forall(GTK_CONTAINER(comboBox), GetInnerWidget, &info);
+
+  if (!comboBoxButton) {
+    /* Shouldn't be reached with current internal gtk implementation; we
+     * use a generic toggle button as last resort fallback to avoid
+     * crashing. */
+    comboBoxButton = GetWidget(MOZ_GTK_TOGGLE_BUTTON);
+  } else {
+    /* We need to have pointers to the inner widgets (button, separator, arrow)
+     * of the ComboBox to get the correct rendering from theme engines which
+     * special cases their look. Since the inner layout can change, we ask GTK
+     * to NULL our pointers when they are about to become invalid because the
+     * corresponding widgets don't exist anymore. It's the role of
+     * g_object_add_weak_pointer().
+     * Note that if we don't find the inner widgets (which shouldn't happen), we
+     * fallback to use generic "non-inner" widgets, and they don't need that
+     * kind of weak pointer since they are explicit children of gProtoLayout and
+     * as such GTK holds a strong reference to them. */
+    g_object_add_weak_pointer(
+        G_OBJECT(comboBoxButton),
+        reinterpret_cast<gpointer*>(sWidgetStorage) + MOZ_GTK_COMBOBOX_BUTTON);
+  }
+
+  return comboBoxButton;
+}
+
+static GtkWidget* CreateComboBoxArrowWidget() {
+  GtkWidget* comboBoxButton = GetWidget(MOZ_GTK_COMBOBOX_BUTTON);
+  GtkWidget* comboBoxArrow = nullptr;
+
+  /* Get the widgets inside the Button */
+  GtkWidget* buttonChild = gtk_bin_get_child(GTK_BIN(comboBoxButton));
+  if (GTK_IS_BOX(buttonChild)) {
+    /* appears-as-list = FALSE, cell-view = TRUE; the button
+     * contains an hbox. This hbox is there because the ComboBox
+     * needs to place a cell renderer, a separator, and an arrow in
+     * the button when appears-as-list is FALSE. */
+    GtkInnerWidgetInfo info = {GTK_TYPE_ARROW, &comboBoxArrow};
+    gtk_container_forall(GTK_CONTAINER(buttonChild), GetInnerWidget, &info);
+  } else if (GTK_IS_ARROW(buttonChild)) {
+    /* appears-as-list = TRUE, or cell-view = FALSE;
+     * the button only contains an arrow */
+    comboBoxArrow = buttonChild;
+  }
+
+  if (!comboBoxArrow) {
+    /* Shouldn't be reached with current internal gtk implementation;
+     * we gButtonArrowWidget as last resort fallback to avoid
+     * crashing. */
+    comboBoxArrow = GetWidget(MOZ_GTK_BUTTON_ARROW);
+  } else {
+    g_object_add_weak_pointer(
+        G_OBJECT(comboBoxArrow),
+        reinterpret_cast<gpointer*>(sWidgetStorage) + MOZ_GTK_COMBOBOX_ARROW);
+  }
+
+  return comboBoxArrow;
+}
+
+static GtkWidget* CreateComboBoxSeparatorWidget() {
+  // Ensure to search for separator only once as it can fail
+  // TODO - it won't initialize after ResetWidgetCache() call
+  static bool isMissingSeparator = false;
+  if (isMissingSeparator) return nullptr;
+
+  /* Get the widgets inside the Button */
+  GtkWidget* comboBoxSeparator = nullptr;
+  GtkWidget* buttonChild =
+      gtk_bin_get_child(GTK_BIN(GetWidget(MOZ_GTK_COMBOBOX_BUTTON)));
+  if (GTK_IS_BOX(buttonChild)) {
+    /* appears-as-list = FALSE, cell-view = TRUE; the button
+     * contains an hbox. This hbox is there because the ComboBox
+     * needs to place a cell renderer, a separator, and an arrow in
+     * the button when appears-as-list is FALSE. */
+    GtkInnerWidgetInfo info = {GTK_TYPE_SEPARATOR, &comboBoxSeparator};
+    gtk_container_forall(GTK_CONTAINER(buttonChild), GetInnerWidget, &info);
+  }
+
+  if (comboBoxSeparator) {
+    g_object_add_weak_pointer(G_OBJECT(comboBoxSeparator),
+                              reinterpret_cast<gpointer*>(sWidgetStorage) +
+                                  MOZ_GTK_COMBOBOX_SEPARATOR);
+  } else {
+    /* comboBoxSeparator may be NULL
+     * when "appears-as-list" = TRUE or "cell-view" = FALSE;
+     * if there is no separator, then we just won't paint it. */
+    isMissingSeparator = true;
+  }
+
+  return comboBoxSeparator;
+}
+
+static GtkWidget* CreateComboBoxEntryWidget() {
+  GtkWidget* widget = gtk_combo_box_new_with_entry();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateComboBoxEntryTextareaWidget() {
+  GtkWidget* comboBoxTextarea = nullptr;
+
+  /* Get its inner Entry and Button */
+  GtkInnerWidgetInfo info = {GTK_TYPE_ENTRY, &comboBoxTextarea};
+  gtk_container_forall(GTK_CONTAINER(GetWidget(MOZ_GTK_COMBOBOX_ENTRY)),
+                       GetInnerWidget, &info);
+
+  if (!comboBoxTextarea) {
+    comboBoxTextarea = GetWidget(MOZ_GTK_ENTRY);
+  } else {
+    g_object_add_weak_pointer(
+        G_OBJECT(comboBoxTextarea),
+        reinterpret_cast<gpointer*>(sWidgetStorage) + MOZ_GTK_COMBOBOX_ENTRY);
+  }
+
+  return comboBoxTextarea;
+}
+
+static GtkWidget* CreateComboBoxEntryButtonWidget() {
+  GtkWidget* comboBoxButton = nullptr;
+
+  /* Get its inner Entry and Button */
+  GtkInnerWidgetInfo info = {GTK_TYPE_TOGGLE_BUTTON, &comboBoxButton};
+  gtk_container_forall(GTK_CONTAINER(GetWidget(MOZ_GTK_COMBOBOX_ENTRY)),
+                       GetInnerWidget, &info);
+
+  if (!comboBoxButton) {
+    comboBoxButton = GetWidget(MOZ_GTK_TOGGLE_BUTTON);
+  } else {
+    g_object_add_weak_pointer(G_OBJECT(comboBoxButton),
+                              reinterpret_cast<gpointer*>(sWidgetStorage) +
+                                  MOZ_GTK_COMBOBOX_ENTRY_BUTTON);
+  }
+
+  return comboBoxButton;
+}
+
+static GtkWidget* CreateComboBoxEntryArrowWidget() {
+  GtkWidget* comboBoxArrow = nullptr;
+
+  /* Get the Arrow inside the Button */
+  GtkWidget* buttonChild =
+      gtk_bin_get_child(GTK_BIN(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON)));
+
+  if (GTK_IS_BOX(buttonChild)) {
+    /* appears-as-list = FALSE, cell-view = TRUE; the button
+     * contains an hbox. This hbox is there because the ComboBox
+     * needs to place a cell renderer, a separator, and an arrow in
+     * the button when appears-as-list is FALSE. */
+    GtkInnerWidgetInfo info = {GTK_TYPE_ARROW, &comboBoxArrow};
+    gtk_container_forall(GTK_CONTAINER(buttonChild), GetInnerWidget, &info);
+  } else if (GTK_IS_ARROW(buttonChild)) {
+    /* appears-as-list = TRUE, or cell-view = FALSE;
+     * the button only contains an arrow */
+    comboBoxArrow = buttonChild;
+  }
+
+  if (!comboBoxArrow) {
+    /* Shouldn't be reached with current internal gtk implementation;
+     * we gButtonArrowWidget as last resort fallback to avoid
+     * crashing. */
+    comboBoxArrow = GetWidget(MOZ_GTK_BUTTON_ARROW);
+  } else {
+    g_object_add_weak_pointer(G_OBJECT(comboBoxArrow),
+                              reinterpret_cast<gpointer*>(sWidgetStorage) +
+                                  MOZ_GTK_COMBOBOX_ENTRY_ARROW);
+  }
+
+  return comboBoxArrow;
+}
+
+static GtkWidget* CreateScrolledWindowWidget() {
+  GtkWidget* widget = gtk_scrolled_window_new(nullptr, nullptr);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateMenuSeparatorWidget() {
+  GtkWidget* widget = gtk_separator_menu_item_new();
+  gtk_menu_shell_append(GTK_MENU_SHELL(GetWidget(MOZ_GTK_MENUPOPUP)), widget);
+  return widget;
+}
+
+static GtkWidget* CreateTreeViewWidget() {
+  GtkWidget* widget = gtk_tree_view_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateTreeHeaderCellWidget() {
+  /*
+   * Some GTK engines paint the first and last cell
+   * of a TreeView header with a highlight.
+   * Since we do not know where our widget will be relative
+   * to the other buttons in the TreeView header, we must
+   * paint it as a button that is between two others,
+   * thus ensuring it is neither the first or last button
+   * in the header.
+   * GTK doesn't give us a way to do this explicitly,
+   * so we must paint with a button that is between two
+   * others.
+   */
+  GtkTreeViewColumn* firstTreeViewColumn;
+  GtkTreeViewColumn* middleTreeViewColumn;
+  GtkTreeViewColumn* lastTreeViewColumn;
+
+  GtkWidget* treeView = GetWidget(MOZ_GTK_TREEVIEW);
+
+  /* Create and append our three columns */
+  firstTreeViewColumn = gtk_tree_view_column_new();
+  gtk_tree_view_column_set_title(firstTreeViewColumn, "M");
+  gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), firstTreeViewColumn);
+
+  middleTreeViewColumn = gtk_tree_view_column_new();
+  gtk_tree_view_column_set_title(middleTreeViewColumn, "M");
+  gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), middleTreeViewColumn);
+
+  lastTreeViewColumn = gtk_tree_view_column_new();
+  gtk_tree_view_column_set_title(lastTreeViewColumn, "M");
+  gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), lastTreeViewColumn);
+
+  /* Use the middle column's header for our button */
+  return gtk_tree_view_column_get_button(middleTreeViewColumn);
+}
+
+static GtkWidget* CreateTreeHeaderSortArrowWidget() {
+  /* TODO, but it can't be NULL */
+  GtkWidget* widget = gtk_button_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateHPanedWidget() {
+  GtkWidget* widget = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateVPanedWidget() {
+  GtkWidget* widget = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateScaleWidget(GtkOrientation aOrientation) {
+  GtkWidget* widget = gtk_scale_new(aOrientation, nullptr);
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static GtkWidget* CreateNotebookWidget() {
+  GtkWidget* widget = gtk_notebook_new();
+  AddToWindowContainer(widget);
+  return widget;
+}
+
+static bool HasBackground(GtkStyleContext* aStyle) {
+  GdkRGBA gdkColor;
+  gtk_style_context_get_background_color(aStyle, GTK_STATE_FLAG_NORMAL,
+                                         &gdkColor);
+  if (gdkColor.alpha != 0.0) {
+    return true;
+  }
+
+  GValue value = G_VALUE_INIT;
+  gtk_style_context_get_property(aStyle, "background-image",
+                                 GTK_STATE_FLAG_NORMAL, &value);
+  auto cleanup = mozilla::MakeScopeExit([&] { g_value_unset(&value); });
+  return g_value_get_boxed(&value);
+}
+
+static void CreateHeaderBarWidget(WidgetNodeType aAppearance) {
+  GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  GtkStyleContext* windowStyle = gtk_widget_get_style_context(window);
+
+  // Headerbar has to be placed to window with csd or solid-csd style
+  // to properly draw the decorated.
+  gtk_style_context_add_class(windowStyle,
+                              IsSolidCSDStyleUsed() ? "solid-csd" : "csd");
+
+  GtkWidget* fixed = gtk_fixed_new();
+  GtkStyleContext* fixedStyle = gtk_widget_get_style_context(fixed);
+  gtk_style_context_add_class(fixedStyle, "titlebar");
+
+  GtkWidget* headerBar = gtk_header_bar_new();
+
+  // Emulate what create_titlebar() at gtkwindow.c does.
+  GtkStyleContext* headerBarStyle = gtk_widget_get_style_context(headerBar);
+  gtk_style_context_add_class(headerBarStyle, "titlebar");
+
+  // TODO: Define default-decoration titlebar style as workaround
+  // to ensure the titlebar buttons does not overflow outside.
+  // Recently the titlebar size is calculated as
+  // tab size + titlebar border/padding (default-decoration has 6px padding
+  // at default Adwaita theme).
+  // We need to fix titlebar size calculation to also include
+  // titlebar button sizes. (Bug 1419442)
+  gtk_style_context_add_class(headerBarStyle, "default-decoration");
+
+  sWidgetStorage[aAppearance] = headerBar;
+  if (aAppearance == MOZ_GTK_HEADER_BAR_MAXIMIZED) {
+    MOZ_ASSERT(!sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW_MAXIMIZED],
+               "Window widget is already created!");
+    MOZ_ASSERT(!sWidgetStorage[MOZ_GTK_HEADERBAR_FIXED_MAXIMIZED],
+               "Fixed widget is already created!");
+
+    gtk_style_context_add_class(windowStyle, "maximized");
+
+    sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW_MAXIMIZED] = window;
+    sWidgetStorage[MOZ_GTK_HEADERBAR_FIXED_MAXIMIZED] = fixed;
+  } else {
+    MOZ_ASSERT(!sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW],
+               "Window widget is already created!");
+    MOZ_ASSERT(!sWidgetStorage[MOZ_GTK_HEADERBAR_FIXED],
+               "Fixed widget is already created!");
+    sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW] = window;
+    sWidgetStorage[MOZ_GTK_HEADERBAR_FIXED] = fixed;
+  }
+
+  gtk_container_add(GTK_CONTAINER(window), fixed);
+  gtk_container_add(GTK_CONTAINER(fixed), headerBar);
+
+  gtk_style_context_invalidate(headerBarStyle);
+  gtk_style_context_invalidate(fixedStyle);
+
+  // Some themes like Elementary's style the container of the headerbar rather
+  // than the header bar itself.
+  bool& shouldDrawContainer = aAppearance == MOZ_GTK_HEADER_BAR
+                                  ? gHeaderBarShouldDrawContainer
+                                  : gMaximizedHeaderBarShouldDrawContainer;
+  shouldDrawContainer = [&] {
+    const bool headerBarHasBackground = HasBackground(headerBarStyle);
+    if (headerBarHasBackground && GetBorderRadius(headerBarStyle)) {
+      return false;
+    }
+    if (HasBackground(fixedStyle) &&
+        (GetBorderRadius(fixedStyle) || !headerBarHasBackground)) {
+      return true;
+    }
+    return false;
+  }();
+}
+
+#define ICON_SCALE_VARIANTS 2
+
+static void LoadWidgetIconPixbuf(GtkWidget* aWidgetIcon) {
+  GtkStyleContext* style = gtk_widget_get_style_context(aWidgetIcon);
+
+  const gchar* iconName;
+  GtkIconSize gtkIconSize;
+  gtk_image_get_icon_name(GTK_IMAGE(aWidgetIcon), &iconName, &gtkIconSize);
+
+  gint iconWidth, iconHeight;
+  gtk_icon_size_lookup(gtkIconSize, &iconWidth, &iconHeight);
+
+  /* Those are available since Gtk+ 3.10 as well as GtkHeaderBar */
+  for (int scale = 1; scale < ICON_SCALE_VARIANTS + 1; scale++) {
+    GtkIconInfo* gtkIconInfo = gtk_icon_theme_lookup_icon_for_scale(
+        gtk_icon_theme_get_default(), iconName, iconWidth, scale,
+        (GtkIconLookupFlags)0);
+
+    if (!gtkIconInfo) {
+      // We miss the icon, nothing to do here.
+      return;
+    }
+
+    gboolean unused;
+    GdkPixbuf* iconPixbuf = gtk_icon_info_load_symbolic_for_context(
+        gtkIconInfo, style, &unused, nullptr);
+    g_object_unref(G_OBJECT(gtkIconInfo));
+
+    cairo_surface_t* iconSurface =
+        gdk_cairo_surface_create_from_pixbuf(iconPixbuf, scale, nullptr);
+    g_object_unref(iconPixbuf);
+
+    nsPrintfCString surfaceName("MozillaIconSurface%d", scale);
+    g_object_set_data_full(G_OBJECT(aWidgetIcon), surfaceName.get(),
+                           iconSurface, (GDestroyNotify)cairo_surface_destroy);
+  }
+}
+
+cairo_surface_t* GetWidgetIconSurface(GtkWidget* aWidgetIcon, int aScale) {
+  if (aScale > ICON_SCALE_VARIANTS) {
+    aScale = ICON_SCALE_VARIANTS;
+  }
+
+  nsPrintfCString surfaceName("MozillaIconSurface%d", aScale);
+  return (cairo_surface_t*)g_object_get_data(G_OBJECT(aWidgetIcon),
+                                             surfaceName.get());
+}
+
+static void CreateHeaderBarButton(GtkWidget* aParentWidget,
+                                  WidgetNodeType aAppearance) {
+  GtkWidget* widget = gtk_button_new();
+
+  // We have to add button to widget hierarchy now to pick
+  // right icon style at LoadWidgetIconPixbuf().
+  if (GTK_IS_BOX(aParentWidget)) {
+    gtk_box_pack_start(GTK_BOX(aParentWidget), widget, FALSE, FALSE, 0);
+  } else {
+    gtk_container_add(GTK_CONTAINER(aParentWidget), widget);
+  }
+
+  // We bypass GetWidget() here because we create all titlebar
+  // buttons at once when a first one is requested.
+  NS_ASSERTION(!sWidgetStorage[aAppearance],
+               "Titlebar button is already created!");
+  sWidgetStorage[aAppearance] = widget;
+
+  // We need to show the button widget now as GtkBox does not
+  // place invisible widgets and we'll miss first-child/last-child
+  // css selectors at the buttons otherwise.
+  gtk_widget_show(widget);
+
+  GtkStyleContext* style = gtk_widget_get_style_context(widget);
+  gtk_style_context_add_class(style, "titlebutton");
+
+  GtkWidget* image = nullptr;
+  switch (aAppearance) {
+    case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
+      gtk_style_context_add_class(style, "close");
+      image = gtk_image_new_from_icon_name("window-close-symbolic",
+                                           GTK_ICON_SIZE_MENU);
+      break;
+    case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
+      gtk_style_context_add_class(style, "minimize");
+      image = gtk_image_new_from_icon_name("window-minimize-symbolic",
+                                           GTK_ICON_SIZE_MENU);
+      break;
+
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
+      gtk_style_context_add_class(style, "maximize");
+      image = gtk_image_new_from_icon_name("window-maximize-symbolic",
+                                           GTK_ICON_SIZE_MENU);
+      break;
+
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE:
+      gtk_style_context_add_class(style, "maximize");
+      image = gtk_image_new_from_icon_name("window-restore-symbolic",
+                                           GTK_ICON_SIZE_MENU);
+      break;
+    default:
+      break;
+  }
+
+  gtk_widget_set_valign(widget, GTK_ALIGN_CENTER);
+  g_object_set(image, "use-fallback", TRUE, NULL);
+  gtk_container_add(GTK_CONTAINER(widget), image);
+
+  // We bypass GetWidget() here by explicit sWidgetStorage[] update so
+  // invalidate the style as well as GetWidget() does.
+  style = gtk_widget_get_style_context(image);
+  gtk_style_context_invalidate(style);
+
+  LoadWidgetIconPixbuf(image);
+}
+
+static bool IsToolbarButtonEnabled(ButtonLayout* aButtonLayout,
+                                   size_t aButtonNums,
+                                   WidgetNodeType aAppearance) {
+  for (size_t i = 0; i < aButtonNums; i++) {
+    if (aButtonLayout[i].mType == aAppearance) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool IsSolidCSDStyleUsed() {
+  if (gCSDStyle == CSDStyle::Unknown) {
+    bool solid;
+    {
+      GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_titlebar(GTK_WINDOW(window), gtk_header_bar_new());
+      gtk_widget_realize(window);
+      GtkStyleContext* windowStyle = gtk_widget_get_style_context(window);
+      solid = gtk_style_context_has_class(windowStyle, "solid-csd");
+      gtk_widget_destroy(window);
+    }
+    gCSDStyle = solid ? CSDStyle::Solid : CSDStyle::Normal;
+  }
+  return gCSDStyle == CSDStyle::Solid;
+}
+
+static void CreateHeaderBarButtons() {
+  GtkWidget* headerBar = sWidgetStorage[MOZ_GTK_HEADER_BAR];
+  MOZ_ASSERT(headerBar != nullptr, "We're missing header bar widget!");
+
+  gint buttonSpacing = 6;
+  g_object_get(headerBar, "spacing", &buttonSpacing, nullptr);
+
+  GtkWidget* buttonBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, buttonSpacing);
+  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_HEADER_BAR)), buttonBox);
+  // We support only LTR headerbar layout for now.
+  gtk_style_context_add_class(gtk_widget_get_style_context(buttonBox),
+                              GTK_STYLE_CLASS_LEFT);
+
+  ButtonLayout buttonLayout[TOOLBAR_BUTTONS];
+
+  size_t activeButtons =
+      GetGtkHeaderBarButtonLayout(mozilla::Span(buttonLayout), nullptr);
+
+  if (IsToolbarButtonEnabled(buttonLayout, activeButtons,
+                             MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE)) {
+    CreateHeaderBarButton(buttonBox, MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE);
+  }
+  if (IsToolbarButtonEnabled(buttonLayout, activeButtons,
+                             MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE)) {
+    CreateHeaderBarButton(buttonBox, MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE);
+    // We don't pack "restore" headerbar button to box as it's an icon
+    // placeholder. Pack it only to header bar to get correct style.
+    CreateHeaderBarButton(GetWidget(MOZ_GTK_HEADER_BAR),
+                          MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE);
+  }
+  if (IsToolbarButtonEnabled(buttonLayout, activeButtons,
+                             MOZ_GTK_HEADER_BAR_BUTTON_CLOSE)) {
+    CreateHeaderBarButton(buttonBox, MOZ_GTK_HEADER_BAR_BUTTON_CLOSE);
+  }
+}
+
+static void CreateHeaderBar() {
+  CreateHeaderBarWidget(MOZ_GTK_HEADER_BAR);
+  CreateHeaderBarWidget(MOZ_GTK_HEADER_BAR_MAXIMIZED);
+  CreateHeaderBarButtons();
+}
+
+static GtkWidget* CreateWidget(WidgetNodeType aAppearance) {
+  switch (aAppearance) {
+    case MOZ_GTK_WINDOW:
+      return CreateWindowWidget();
+    case MOZ_GTK_WINDOW_CONTAINER:
+      return CreateWindowContainerWidget();
+    case MOZ_GTK_CHECKBUTTON_CONTAINER:
+      return CreateCheckboxWidget();
+    case MOZ_GTK_PROGRESSBAR:
+      return CreateProgressWidget();
+    case MOZ_GTK_RADIOBUTTON_CONTAINER:
+      return CreateRadiobuttonWidget();
+    case MOZ_GTK_SCROLLBAR_VERTICAL:
+      return CreateScrollbarWidget(aAppearance, GTK_ORIENTATION_VERTICAL);
+    case MOZ_GTK_MENUBAR:
+      return CreateMenuBarWidget();
+    case MOZ_GTK_MENUPOPUP:
+      return CreateMenuPopupWidget();
+    case MOZ_GTK_MENUSEPARATOR:
+      return CreateMenuSeparatorWidget();
+    case MOZ_GTK_EXPANDER:
+      return CreateExpanderWidget();
+    case MOZ_GTK_FRAME:
+      return CreateFrameWidget();
+    case MOZ_GTK_GRIPPER:
+      return CreateGripperWidget();
+    case MOZ_GTK_TOOLBAR:
+      return CreateToolbarWidget();
+    case MOZ_GTK_TOOLBAR_SEPARATOR:
+      return CreateToolbarSeparatorWidget();
+    case MOZ_GTK_SPINBUTTON:
+      return CreateSpinWidget();
+    case MOZ_GTK_BUTTON:
+      return CreateButtonWidget();
+    case MOZ_GTK_TOGGLE_BUTTON:
+      return CreateToggleButtonWidget();
+    case MOZ_GTK_BUTTON_ARROW:
+      return CreateButtonArrowWidget();
+    case MOZ_GTK_ENTRY:
+    case MOZ_GTK_DROPDOWN_ENTRY:
+      return CreateEntryWidget();
+    case MOZ_GTK_SCROLLED_WINDOW:
+      return CreateScrolledWindowWidget();
+    case MOZ_GTK_TREEVIEW:
+      return CreateTreeViewWidget();
+    case MOZ_GTK_TREE_HEADER_CELL:
+      return CreateTreeHeaderCellWidget();
+    case MOZ_GTK_TREE_HEADER_SORTARROW:
+      return CreateTreeHeaderSortArrowWidget();
+    case MOZ_GTK_SPLITTER_HORIZONTAL:
+      return CreateHPanedWidget();
+    case MOZ_GTK_SPLITTER_VERTICAL:
+      return CreateVPanedWidget();
+    case MOZ_GTK_SCALE_HORIZONTAL:
+      return CreateScaleWidget(GTK_ORIENTATION_HORIZONTAL);
+    case MOZ_GTK_SCALE_VERTICAL:
+      return CreateScaleWidget(GTK_ORIENTATION_VERTICAL);
+    case MOZ_GTK_NOTEBOOK:
+      return CreateNotebookWidget();
+    case MOZ_GTK_COMBOBOX:
+      return CreateComboBoxWidget();
+    case MOZ_GTK_COMBOBOX_BUTTON:
+      return CreateComboBoxButtonWidget();
+    case MOZ_GTK_COMBOBOX_ARROW:
+      return CreateComboBoxArrowWidget();
+    case MOZ_GTK_COMBOBOX_SEPARATOR:
+      return CreateComboBoxSeparatorWidget();
+    case MOZ_GTK_COMBOBOX_ENTRY:
+      return CreateComboBoxEntryWidget();
+    case MOZ_GTK_COMBOBOX_ENTRY_TEXTAREA:
+      return CreateComboBoxEntryTextareaWidget();
+    case MOZ_GTK_COMBOBOX_ENTRY_BUTTON:
+      return CreateComboBoxEntryButtonWidget();
+    case MOZ_GTK_COMBOBOX_ENTRY_ARROW:
+      return CreateComboBoxEntryArrowWidget();
+    case MOZ_GTK_HEADERBAR_WINDOW:
+    case MOZ_GTK_HEADERBAR_WINDOW_MAXIMIZED:
+    case MOZ_GTK_HEADERBAR_FIXED:
+    case MOZ_GTK_HEADERBAR_FIXED_MAXIMIZED:
+    case MOZ_GTK_HEADER_BAR:
+    case MOZ_GTK_HEADER_BAR_MAXIMIZED:
+    case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE:
+      /* Create header bar widgets once and fill with child elements as we need
+         the header bar fully configured to get a correct style */
+      CreateHeaderBar();
+      return sWidgetStorage[aAppearance];
+    default:
+      /* Not implemented */
+      return nullptr;
+  }
+}
+
+GtkWidget* GetWidget(WidgetNodeType aAppearance) {
+  GtkWidget* widget = sWidgetStorage[aAppearance];
+  if (!widget) {
+    widget = CreateWidget(aAppearance);
+    // Some widgets (MOZ_GTK_COMBOBOX_SEPARATOR for instance) may not be
+    // available or implemented.
+    if (!widget) {
+      return nullptr;
+    }
+    // In GTK versions prior to 3.18, automatic invalidation of style contexts
+    // for widgets was delayed until the next resize event.  Gecko however,
+    // typically uses the style context before the resize event runs and so an
+    // explicit invalidation may be required.  This is necessary if a style
+    // property was retrieved before all changes were made to the style
+    // context.  One such situation is where gtk_button_construct_child()
+    // retrieves the style property "image-spacing" during construction of the
+    // GtkButton, before its parent is set to provide inheritance of ancestor
+    // properties.  More recent GTK versions do not need this, but do not
+    // re-resolve until required and so invalidation does not trigger
+    // unnecessary resolution in general.
+    GtkStyleContext* style = gtk_widget_get_style_context(widget);
+    gtk_style_context_invalidate(style);
+
+    sWidgetStorage[aAppearance] = widget;
+  }
+  return widget;
+}
+
+static void AddStyleClassesFromStyle(GtkStyleContext* aDest,
+                                     GtkStyleContext* aSrc) {
+  GList* classes = gtk_style_context_list_classes(aSrc);
+  for (GList* link = classes; link; link = link->next) {
+    gtk_style_context_add_class(aDest, static_cast<gchar*>(link->data));
+  }
+  g_list_free(classes);
+}
+
+GtkStyleContext* CreateStyleForWidget(GtkWidget* aWidget,
+                                      GtkStyleContext* aParentStyle) {
+  static auto sGtkWidgetClassGetCSSName =
+      reinterpret_cast<const char* (*)(GtkWidgetClass*)>(
+          dlsym(RTLD_DEFAULT, "gtk_widget_class_get_css_name"));
+
+  GtkWidgetClass* widgetClass = GTK_WIDGET_GET_CLASS(aWidget);
+  const gchar* name = sGtkWidgetClassGetCSSName
+                          ? sGtkWidgetClassGetCSSName(widgetClass)
+                          : nullptr;
+
+  GtkStyleContext* context =
+      CreateCSSNode(name, aParentStyle, G_TYPE_FROM_CLASS(widgetClass));
+
+  // Classes are stored on the style context instead of the path so that any
+  // future gtk_style_context_save() will inherit classes on the head CSS
+  // node, in the same way as happens when called on a style context owned by
+  // a widget.
+  //
+  // Classes can be stored on a GtkCssNodeDeclaration and/or the path.
+  // gtk_style_context_save() reuses the GtkCssNodeDeclaration, and appends a
+  // new object to the path, without copying the classes from the old path
+  // head.  The new head picks up classes from the GtkCssNodeDeclaration, but
+  // not the path.  GtkWidgets store their classes on the
+  // GtkCssNodeDeclaration, so make sure to add classes there.
+  //
+  // Picking up classes from the style context also means that
+  // https://bugzilla.gnome.org/show_bug.cgi?id=767312, which can stop
+  // gtk_widget_path_append_for_widget() from finding classes in GTK 3.20,
+  // is not a problem.
+  GtkStyleContext* widgetStyle = gtk_widget_get_style_context(aWidget);
+  AddStyleClassesFromStyle(context, widgetStyle);
+
+  // Release any floating reference on aWidget.
+  g_object_ref_sink(aWidget);
+  g_object_unref(aWidget);
+
+  return context;
+}
+
+static GtkStyleContext* CreateStyleForWidget(GtkWidget* aWidget,
+                                             WidgetNodeType aParentType) {
+  return CreateStyleForWidget(aWidget, GetWidgetRootStyle(aParentType));
+}
+
+GtkStyleContext* CreateCSSNode(const char* aName, GtkStyleContext* aParentStyle,
+                               GType aType) {
+  static auto sGtkWidgetPathIterSetObjectName =
+      reinterpret_cast<void (*)(GtkWidgetPath*, gint, const char*)>(
+          dlsym(RTLD_DEFAULT, "gtk_widget_path_iter_set_object_name"));
+
+  GtkWidgetPath* path;
+  if (aParentStyle) {
+    path = gtk_widget_path_copy(gtk_style_context_get_path(aParentStyle));
+    // Copy classes from the parent style context to its corresponding node in
+    // the path, because GTK will only match against ancestor classes if they
+    // are on the path.
+    GList* classes = gtk_style_context_list_classes(aParentStyle);
+    for (GList* link = classes; link; link = link->next) {
+      gtk_widget_path_iter_add_class(path, -1, static_cast<gchar*>(link->data));
+    }
+    g_list_free(classes);
+  } else {
+    path = gtk_widget_path_new();
+  }
+
+  gtk_widget_path_append_type(path, aType);
+
+  if (sGtkWidgetPathIterSetObjectName) {
+    (*sGtkWidgetPathIterSetObjectName)(path, -1, aName);
+  }
+
+  GtkStyleContext* context = gtk_style_context_new();
+  gtk_style_context_set_path(context, path);
+  gtk_style_context_set_parent(context, aParentStyle);
+  gtk_widget_path_unref(path);
+
+  // In GTK 3.4, gtk_render_* functions use |theming_engine| on the style
+  // context without ensuring any style resolution sets it appropriately
+  // in style_data_lookup(). e.g.
+  // https://git.gnome.org/browse/gtk+/tree/gtk/gtkstylecontext.c?h=3.4.4#n3847
+  //
+  // That can result in incorrect drawing on first draw.  To work around this,
+  // force a style look-up to set |theming_engine|.  It is sufficient to do
+  // this only on context creation, instead of after every modification to the
+  // context, because themes typically (Ambiance and oxygen-gtk, at least) set
+  // the "engine" property with the '*' selector.
+  if (GTK_MAJOR_VERSION == 3 && gtk_get_minor_version() < 6) {
+    GdkRGBA unused;
+    gtk_style_context_get_color(context, GTK_STATE_FLAG_NORMAL, &unused);
+  }
+
+  return context;
+}
+
+// Return a style context matching that of the root CSS node of a widget.
+// This is used by all GTK versions.
+static GtkStyleContext* GetWidgetRootStyle(WidgetNodeType aNodeType) {
+  GtkStyleContext* style = sStyleStorage[aNodeType];
+  if (style) return style;
+
+  switch (aNodeType) {
+    case MOZ_GTK_MENUBARITEM:
+      style = CreateStyleForWidget(gtk_menu_item_new(), MOZ_GTK_MENUBAR);
+      break;
+    case MOZ_GTK_MENUITEM:
+      style = CreateStyleForWidget(gtk_menu_item_new(), MOZ_GTK_MENUPOPUP);
+      break;
+    case MOZ_GTK_CHECKMENUITEM:
+      style =
+          CreateStyleForWidget(gtk_check_menu_item_new(), MOZ_GTK_MENUPOPUP);
+      break;
+    case MOZ_GTK_RADIOMENUITEM:
+      style = CreateStyleForWidget(gtk_radio_menu_item_new(nullptr),
+                                   MOZ_GTK_MENUPOPUP);
+      break;
+    case MOZ_GTK_TEXT_VIEW:
+      style =
+          CreateStyleForWidget(gtk_text_view_new(), MOZ_GTK_SCROLLED_WINDOW);
+      break;
+    case MOZ_GTK_TOOLTIP:
+      if (gtk_check_version(3, 20, 0) != nullptr) {
+        // The tooltip style class is added first in CreateTooltipWidget()
+        // and transfered to style in CreateStyleForWidget().
+        GtkWidget* tooltipWindow = CreateTooltipWidget();
+        style = CreateStyleForWidget(tooltipWindow, nullptr);
+        gtk_widget_destroy(tooltipWindow);  // Release GtkWindow self-reference.
+      } else {
+        // We create this from the path because GtkTooltipWindow is not public.
+        style = CreateCSSNode("tooltip", nullptr, GTK_TYPE_TOOLTIP);
+        gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND);
+      }
+      break;
+    case MOZ_GTK_TOOLTIP_BOX:
+      style = CreateStyleForWidget(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0),
+                                   MOZ_GTK_TOOLTIP);
+      break;
+    case MOZ_GTK_TOOLTIP_BOX_LABEL:
+      style = CreateStyleForWidget(gtk_label_new(nullptr), MOZ_GTK_TOOLTIP_BOX);
+      break;
+    default:
+      GtkWidget* widget = GetWidget(aNodeType);
+      MOZ_ASSERT(widget);
+      return gtk_widget_get_style_context(widget);
+  }
+
+  MOZ_ASSERT(style);
+  sStyleStorage[aNodeType] = style;
+  return style;
+}
+
+static GtkStyleContext* CreateChildCSSNode(const char* aName,
+                                           WidgetNodeType aParentNodeType) {
+  return CreateCSSNode(aName, GetCssNodeStyleInternal(aParentNodeType));
+}
+
+// Create a style context equivalent to a saved root style context of
+// |aAppearance| with |aStyleClass| as an additional class.  This is used to
+// produce a context equivalent to what GTK versions < 3.20 use for many
+// internal parts of widgets.
+static GtkStyleContext* CreateSubStyleWithClass(WidgetNodeType aAppearance,
+                                                const gchar* aStyleClass) {
+  static auto sGtkWidgetPathIterGetObjectName =
+      reinterpret_cast<const char* (*)(const GtkWidgetPath*, gint)>(
+          dlsym(RTLD_DEFAULT, "gtk_widget_path_iter_get_object_name"));
+
+  GtkStyleContext* parentStyle = GetWidgetRootStyle(aAppearance);
+
+  // Create a new context that behaves like |parentStyle| would after
+  // gtk_style_context_save(parentStyle).
+  //
+  // Avoiding gtk_style_context_save() avoids the need to manage the
+  // restore, and a new context permits caching style resolution.
+  //
+  // gtk_style_context_save(context) changes the node hierarchy of |context|
+  // to add a new GtkCssNodeDeclaration that is a copy of its original node.
+  // The new node is a child of the original node, and so the new heirarchy is
+  // one level deeper.  The new node receives the same classes as the
+  // original, but any changes to the classes on |context| will change only
+  // the new node.  The new node inherits properties from the original node
+  // (which retains the original heirarchy and classes) and matches CSS rules
+  // with the new heirarchy and any changes to the classes.
+  //
+  // The change in hierarchy can produce some surprises in matching theme CSS
+  // rules (e.g. https://bugzilla.gnome.org/show_bug.cgi?id=761870#c2), but it
+  // is important here to produce the same behavior so that rules match the
+  // same widget parts in Gecko as they do in GTK.
+  //
+  // When using public GTK API to construct style contexts, a widget path is
+  // required.  CSS rules are not matched against the style context heirarchy
+  // but according to the heirarchy in the widget path.  The path that matches
+  // the same CSS rules as a saved context is like the path of |parentStyle|
+  // but with an extra copy of the head (last) object appended.  Setting
+  // |parentStyle| as the parent context provides the same inheritance of
+  // properties from the widget root node.
+  const GtkWidgetPath* parentPath = gtk_style_context_get_path(parentStyle);
+  const gchar* name = sGtkWidgetPathIterGetObjectName
+                          ? sGtkWidgetPathIterGetObjectName(parentPath, -1)
+                          : nullptr;
+  GType objectType = gtk_widget_path_get_object_type(parentPath);
+
+  GtkStyleContext* style = CreateCSSNode(name, parentStyle, objectType);
+
+  // Start with the same classes on the new node as were on |parentStyle|.
+  // GTK puts no regions or junction_sides on widget root nodes, and so there
+  // is no need to copy these.
+  AddStyleClassesFromStyle(style, parentStyle);
+
+  gtk_style_context_add_class(style, aStyleClass);
+  return style;
+}
+
+/* GetCssNodeStyleInternal is used by Gtk >= 3.20 */
+static GtkStyleContext* GetCssNodeStyleInternal(WidgetNodeType aNodeType) {
+  GtkStyleContext* style = sStyleStorage[aNodeType];
+  if (style) return style;
+
+  switch (aNodeType) {
+    case MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL:
+      style = CreateChildCSSNode("contents", MOZ_GTK_SCROLLBAR_VERTICAL);
+      break;
+    case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH,
+                                 MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL);
+      break;
+    case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_SLIDER,
+                                 MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL);
+      break;
+    case MOZ_GTK_RADIOBUTTON:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_RADIO,
+                                 MOZ_GTK_RADIOBUTTON_CONTAINER);
+      break;
+    case MOZ_GTK_CHECKBUTTON:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_CHECK,
+                                 MOZ_GTK_CHECKBUTTON_CONTAINER);
+      break;
+    case MOZ_GTK_RADIOMENUITEM_INDICATOR:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_RADIO, MOZ_GTK_RADIOMENUITEM);
+      break;
+    case MOZ_GTK_CHECKMENUITEM_INDICATOR:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_CHECK, MOZ_GTK_CHECKMENUITEM);
+      break;
+    case MOZ_GTK_PROGRESS_TROUGH:
+      /* Progress bar background (trough) */
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH, MOZ_GTK_PROGRESSBAR);
+      break;
+    case MOZ_GTK_PROGRESS_CHUNK:
+      style = CreateChildCSSNode("progress", MOZ_GTK_PROGRESS_TROUGH);
+      break;
+    case MOZ_GTK_GRIPPER:
+      // TODO - create from CSS node
+      style = CreateSubStyleWithClass(MOZ_GTK_GRIPPER, GTK_STYLE_CLASS_GRIP);
+      break;
+    case MOZ_GTK_SPINBUTTON_ENTRY:
+      // TODO - create from CSS node
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_SPINBUTTON, GTK_STYLE_CLASS_ENTRY);
+      break;
+    case MOZ_GTK_SCROLLED_WINDOW:
+      // TODO - create from CSS node
+      style = CreateSubStyleWithClass(MOZ_GTK_SCROLLED_WINDOW,
+                                      GTK_STYLE_CLASS_FRAME);
+      break;
+    case MOZ_GTK_TEXT_VIEW_TEXT_SELECTION:
+      style = CreateChildCSSNode("selection", MOZ_GTK_TEXT_VIEW_TEXT);
+      break;
+    case MOZ_GTK_TEXT_VIEW_TEXT:
+    case MOZ_GTK_RESIZER:
+      style = CreateChildCSSNode("text", MOZ_GTK_TEXT_VIEW);
+      if (aNodeType == MOZ_GTK_RESIZER) {
+        // The "grip" class provides the correct builtin icon from
+        // gtk_render_handle().  The icon is drawn with shaded variants of
+        // the background color, and so a transparent background would lead to
+        // a transparent resizer.  gtk_render_handle() also uses the
+        // background color to draw a background, and so this style otherwise
+        // matches what is used in GtkTextView to match the background with
+        // textarea elements.
+        GdkRGBA color;
+        gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL,
+                                               &color);
+        if (color.alpha == 0.0) {
+          g_object_unref(style);
+          style = CreateStyleForWidget(gtk_text_view_new(),
+                                       MOZ_GTK_SCROLLED_WINDOW);
+        }
+        gtk_style_context_add_class(style, GTK_STYLE_CLASS_GRIP);
+      }
+      break;
+    case MOZ_GTK_FRAME_BORDER:
+      style = CreateChildCSSNode("border", MOZ_GTK_FRAME);
+      break;
+    case MOZ_GTK_TREEVIEW_VIEW:
+      // TODO - create from CSS node
+      style = CreateSubStyleWithClass(MOZ_GTK_TREEVIEW, GTK_STYLE_CLASS_VIEW);
+      break;
+    case MOZ_GTK_TREEVIEW_EXPANDER:
+      // TODO - create from CSS node
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_TREEVIEW, GTK_STYLE_CLASS_EXPANDER);
+      break;
+    case MOZ_GTK_SPLITTER_SEPARATOR_HORIZONTAL:
+      style = CreateChildCSSNode("separator", MOZ_GTK_SPLITTER_HORIZONTAL);
+      break;
+    case MOZ_GTK_SPLITTER_SEPARATOR_VERTICAL:
+      style = CreateChildCSSNode("separator", MOZ_GTK_SPLITTER_VERTICAL);
+      break;
+    case MOZ_GTK_SCALE_CONTENTS_HORIZONTAL:
+      style = CreateChildCSSNode("contents", MOZ_GTK_SCALE_HORIZONTAL);
+      break;
+    case MOZ_GTK_SCALE_CONTENTS_VERTICAL:
+      style = CreateChildCSSNode("contents", MOZ_GTK_SCALE_VERTICAL);
+      break;
+    case MOZ_GTK_SCALE_TROUGH_HORIZONTAL:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH,
+                                 MOZ_GTK_SCALE_CONTENTS_HORIZONTAL);
+      break;
+    case MOZ_GTK_SCALE_TROUGH_VERTICAL:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH,
+                                 MOZ_GTK_SCALE_CONTENTS_VERTICAL);
+      break;
+    case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_SLIDER,
+                                 MOZ_GTK_SCALE_TROUGH_HORIZONTAL);
+      break;
+    case MOZ_GTK_SCALE_THUMB_VERTICAL:
+      style = CreateChildCSSNode(GTK_STYLE_CLASS_SLIDER,
+                                 MOZ_GTK_SCALE_TROUGH_VERTICAL);
+      break;
+    case MOZ_GTK_TAB_TOP: {
+      // TODO - create from CSS node
+      style = CreateSubStyleWithClass(MOZ_GTK_NOTEBOOK, GTK_STYLE_CLASS_TOP);
+      gtk_style_context_add_region(style, GTK_STYLE_REGION_TAB,
+                                   static_cast<GtkRegionFlags>(0));
+      break;
+    }
+    case MOZ_GTK_TAB_BOTTOM: {
+      // TODO - create from CSS node
+      style = CreateSubStyleWithClass(MOZ_GTK_NOTEBOOK, GTK_STYLE_CLASS_BOTTOM);
+      gtk_style_context_add_region(style, GTK_STYLE_REGION_TAB,
+                                   static_cast<GtkRegionFlags>(0));
+      break;
+    }
+    case MOZ_GTK_NOTEBOOK:
+    case MOZ_GTK_NOTEBOOK_HEADER:
+    case MOZ_GTK_TABPANELS:
+    case MOZ_GTK_TAB_SCROLLARROW: {
+      // TODO - create from CSS node
+      GtkWidget* widget = GetWidget(MOZ_GTK_NOTEBOOK);
+      return gtk_widget_get_style_context(widget);
+    }
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE: {
+      NS_ASSERTION(
+          false, "MOZ_GTK_HEADER_BAR_BUTTON_RESTORE is used as an icon only!");
+      return nullptr;
+    }
+    case MOZ_GTK_MENUPOPUP_DECORATION: {
+      GtkStyleContext* parentStyle =
+          CreateSubStyleWithClass(MOZ_GTK_MENUPOPUP, "csd");
+      style = CreateCSSNode("decoration", parentStyle);
+      g_object_unref(parentStyle);
+      break;
+    }
+    case MOZ_GTK_WINDOW_DECORATION: {
+      GtkStyleContext* parentStyle =
+          CreateSubStyleWithClass(MOZ_GTK_WINDOW, "csd");
+      style = CreateCSSNode("decoration", parentStyle);
+      g_object_unref(parentStyle);
+      break;
+    }
+    case MOZ_GTK_WINDOW_DECORATION_SOLID: {
+      GtkStyleContext* parentStyle =
+          CreateSubStyleWithClass(MOZ_GTK_WINDOW, "solid-csd");
+      style = CreateCSSNode("decoration", parentStyle);
+      g_object_unref(parentStyle);
+      break;
+    }
+    default:
+      return GetWidgetRootStyle(aNodeType);
+  }
+
+  MOZ_ASSERT(style, "missing style context for node type");
+  sStyleStorage[aNodeType] = style;
+  return style;
+}
+
+/* GetWidgetStyleInternal is used by Gtk < 3.20 */
+static GtkStyleContext* GetWidgetStyleInternal(WidgetNodeType aNodeType) {
+  GtkStyleContext* style = sStyleStorage[aNodeType];
+  if (style) return style;
+
+  switch (aNodeType) {
+    case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCROLLBAR_VERTICAL,
+                                      GTK_STYLE_CLASS_TROUGH);
+      break;
+    case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCROLLBAR_VERTICAL,
+                                      GTK_STYLE_CLASS_SLIDER);
+      break;
+    case MOZ_GTK_RADIOBUTTON:
+      style = CreateSubStyleWithClass(MOZ_GTK_RADIOBUTTON_CONTAINER,
+                                      GTK_STYLE_CLASS_RADIO);
+      break;
+    case MOZ_GTK_CHECKBUTTON:
+      style = CreateSubStyleWithClass(MOZ_GTK_CHECKBUTTON_CONTAINER,
+                                      GTK_STYLE_CLASS_CHECK);
+      break;
+    case MOZ_GTK_RADIOMENUITEM_INDICATOR:
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_RADIOMENUITEM, GTK_STYLE_CLASS_RADIO);
+      break;
+    case MOZ_GTK_CHECKMENUITEM_INDICATOR:
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_CHECKMENUITEM, GTK_STYLE_CLASS_CHECK);
+      break;
+    case MOZ_GTK_PROGRESS_TROUGH:
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_PROGRESSBAR, GTK_STYLE_CLASS_TROUGH);
+      break;
+    case MOZ_GTK_PROGRESS_CHUNK:
+      style = CreateSubStyleWithClass(MOZ_GTK_PROGRESSBAR,
+                                      GTK_STYLE_CLASS_PROGRESSBAR);
+      gtk_style_context_remove_class(style, GTK_STYLE_CLASS_TROUGH);
+      break;
+    case MOZ_GTK_GRIPPER:
+      style = CreateSubStyleWithClass(MOZ_GTK_GRIPPER, GTK_STYLE_CLASS_GRIP);
+      break;
+    case MOZ_GTK_SPINBUTTON_ENTRY:
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_SPINBUTTON, GTK_STYLE_CLASS_ENTRY);
+      break;
+    case MOZ_GTK_SCROLLED_WINDOW:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCROLLED_WINDOW,
+                                      GTK_STYLE_CLASS_FRAME);
+      break;
+    case MOZ_GTK_TEXT_VIEW_TEXT:
+    case MOZ_GTK_RESIZER:
+      // GTK versions prior to 3.20 do not have the view class on the root
+      // node, but add this to determine the background for the text window.
+      style = CreateSubStyleWithClass(MOZ_GTK_TEXT_VIEW, GTK_STYLE_CLASS_VIEW);
+      if (aNodeType == MOZ_GTK_RESIZER) {
+        // The "grip" class provides the correct builtin icon from
+        // gtk_render_handle().  The icon is drawn with shaded variants of
+        // the background color, and so a transparent background would lead to
+        // a transparent resizer.  gtk_render_handle() also uses the
+        // background color to draw a background, and so this style otherwise
+        // matches MOZ_GTK_TEXT_VIEW_TEXT to match the background with
+        // textarea elements.  GtkTextView creates a separate text window and
+        // so the background should not be transparent.
+        gtk_style_context_add_class(style, GTK_STYLE_CLASS_GRIP);
+      }
+      break;
+    case MOZ_GTK_FRAME_BORDER:
+      return GetWidgetRootStyle(MOZ_GTK_FRAME);
+    case MOZ_GTK_TREEVIEW_VIEW:
+      style = CreateSubStyleWithClass(MOZ_GTK_TREEVIEW, GTK_STYLE_CLASS_VIEW);
+      break;
+    case MOZ_GTK_TREEVIEW_EXPANDER:
+      style =
+          CreateSubStyleWithClass(MOZ_GTK_TREEVIEW, GTK_STYLE_CLASS_EXPANDER);
+      break;
+    case MOZ_GTK_SPLITTER_SEPARATOR_HORIZONTAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SPLITTER_HORIZONTAL,
+                                      GTK_STYLE_CLASS_PANE_SEPARATOR);
+      break;
+    case MOZ_GTK_SPLITTER_SEPARATOR_VERTICAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SPLITTER_VERTICAL,
+                                      GTK_STYLE_CLASS_PANE_SEPARATOR);
+      break;
+    case MOZ_GTK_SCALE_TROUGH_HORIZONTAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCALE_HORIZONTAL,
+                                      GTK_STYLE_CLASS_TROUGH);
+      break;
+    case MOZ_GTK_SCALE_TROUGH_VERTICAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCALE_VERTICAL,
+                                      GTK_STYLE_CLASS_TROUGH);
+      break;
+    case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCALE_HORIZONTAL,
+                                      GTK_STYLE_CLASS_SLIDER);
+      break;
+    case MOZ_GTK_SCALE_THUMB_VERTICAL:
+      style = CreateSubStyleWithClass(MOZ_GTK_SCALE_VERTICAL,
+                                      GTK_STYLE_CLASS_SLIDER);
+      break;
+    case MOZ_GTK_TAB_TOP:
+      style = CreateSubStyleWithClass(MOZ_GTK_NOTEBOOK, GTK_STYLE_CLASS_TOP);
+      gtk_style_context_add_region(style, GTK_STYLE_REGION_TAB,
+                                   static_cast<GtkRegionFlags>(0));
+      break;
+    case MOZ_GTK_TAB_BOTTOM:
+      style = CreateSubStyleWithClass(MOZ_GTK_NOTEBOOK, GTK_STYLE_CLASS_BOTTOM);
+      gtk_style_context_add_region(style, GTK_STYLE_REGION_TAB,
+                                   static_cast<GtkRegionFlags>(0));
+      break;
+    case MOZ_GTK_NOTEBOOK:
+    case MOZ_GTK_NOTEBOOK_HEADER:
+    case MOZ_GTK_TABPANELS:
+    case MOZ_GTK_TAB_SCROLLARROW: {
+      GtkWidget* widget = GetWidget(MOZ_GTK_NOTEBOOK);
+      return gtk_widget_get_style_context(widget);
+    }
+    default:
+      return GetWidgetRootStyle(aNodeType);
+  }
+
+  MOZ_ASSERT(style);
+  sStyleStorage[aNodeType] = style;
+  return style;
+}
+
+void ResetWidgetCache() {
+  for (int i = 0; i < MOZ_GTK_WIDGET_NODE_COUNT; i++) {
+    if (sStyleStorage[i]) g_object_unref(sStyleStorage[i]);
+  }
+  mozilla::PodArrayZero(sStyleStorage);
+
+  gCSDStyle = CSDStyle::Unknown;
+
+  /* This will destroy all of our widgets */
+  if (sWidgetStorage[MOZ_GTK_WINDOW]) {
+    gtk_widget_destroy(sWidgetStorage[MOZ_GTK_WINDOW]);
+  }
+  if (sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW]) {
+    gtk_widget_destroy(sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW]);
+  }
+  if (sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW_MAXIMIZED]) {
+    gtk_widget_destroy(sWidgetStorage[MOZ_GTK_HEADERBAR_WINDOW_MAXIMIZED]);
+  }
+
+  /* Clear already freed arrays */
+  mozilla::PodArrayZero(sWidgetStorage);
+}
+
+GtkStyleContext* GetStyleContext(WidgetNodeType aNodeType, int aScale,
+                                 GtkTextDirection aDirection,
+                                 GtkStateFlags aStateFlags) {
+  GtkStyleContext* style;
+  if (gtk_check_version(3, 20, 0) != nullptr) {
+    style = GetWidgetStyleInternal(aNodeType);
+  } else {
+    style = GetCssNodeStyleInternal(aNodeType);
+    StyleContextSetScale(style, aScale);
+  }
+  bool stateChanged = false;
+  bool stateHasDirection = gtk_get_minor_version() >= 8;
+  GtkStateFlags oldState = gtk_style_context_get_state(style);
+  MOZ_ASSERT(!(aStateFlags & (STATE_FLAG_DIR_LTR | STATE_FLAG_DIR_RTL)));
+  unsigned newState = aStateFlags;
+  if (stateHasDirection) {
+    switch (aDirection) {
+      case GTK_TEXT_DIR_LTR:
+        newState |= STATE_FLAG_DIR_LTR;
+        break;
+      case GTK_TEXT_DIR_RTL:
+        newState |= STATE_FLAG_DIR_RTL;
+        break;
+      default:
+        MOZ_FALLTHROUGH_ASSERT("Bad GtkTextDirection");
+      case GTK_TEXT_DIR_NONE:
+        // GtkWidget uses a default direction if neither is explicitly
+        // specified, but here DIR_NONE is interpreted as meaning the
+        // direction is not important, so don't change the direction
+        // unnecessarily.
+        newState |= oldState & (STATE_FLAG_DIR_LTR | STATE_FLAG_DIR_RTL);
+    }
+  } else if (aDirection != GTK_TEXT_DIR_NONE) {
+    GtkTextDirection oldDirection = gtk_style_context_get_direction(style);
+    if (aDirection != oldDirection) {
+      gtk_style_context_set_direction(style, aDirection);
+      stateChanged = true;
+    }
+  }
+  if (oldState != newState) {
+    gtk_style_context_set_state(style, static_cast<GtkStateFlags>(newState));
+    stateChanged = true;
+  }
+  // This invalidate is necessary for unsaved style contexts from GtkWidgets
+  // in pre-3.18 GTK, because automatic invalidation of such contexts
+  // was delayed until a resize event runs.
+  //
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=1272194#c7
+  //
+  // Avoid calling invalidate on contexts that are not owned and constructed
+  // by widgets to avoid performing build_properties() (in 3.16 stylecontext.c)
+  // unnecessarily early.
+  if (stateChanged && sWidgetStorage[aNodeType]) {
+    gtk_style_context_invalidate(style);
+  }
+  return style;
+}
+
+GtkStyleContext* CreateStyleContextWithStates(WidgetNodeType aNodeType,
+                                              int aScale,
+                                              GtkTextDirection aDirection,
+                                              GtkStateFlags aStateFlags) {
+  GtkStyleContext* style =
+      GetStyleContext(aNodeType, aScale, aDirection, aStateFlags);
+  GtkWidgetPath* path = gtk_widget_path_copy(gtk_style_context_get_path(style));
+
+  static auto sGtkWidgetPathIterGetState =
+      (GtkStateFlags(*)(const GtkWidgetPath*, gint))dlsym(
+          RTLD_DEFAULT, "gtk_widget_path_iter_get_state");
+  static auto sGtkWidgetPathIterSetState =
+      (void (*)(GtkWidgetPath*, gint, GtkStateFlags))dlsym(
+          RTLD_DEFAULT, "gtk_widget_path_iter_set_state");
+
+  int pathLength = gtk_widget_path_length(path);
+  for (int i = 0; i < pathLength; i++) {
+    unsigned state = aStateFlags | sGtkWidgetPathIterGetState(path, i);
+    sGtkWidgetPathIterSetState(path, i, GtkStateFlags(state));
+  }
+
+  style = gtk_style_context_new();
+  gtk_style_context_set_path(style, path);
+  gtk_widget_path_unref(path);
+
+  return style;
+}
+
+void StyleContextSetScale(GtkStyleContext* style, gint aScaleFactor) {
+  // Support HiDPI styles on Gtk 3.20+
+  static auto sGtkStyleContextSetScalePtr =
+      (void (*)(GtkStyleContext*, gint))dlsym(RTLD_DEFAULT,
+                                              "gtk_style_context_set_scale");
+  if (sGtkStyleContextSetScalePtr && style) {
+    sGtkStyleContextSetScalePtr(style, aScaleFactor);
+  }
+}
+
+bool HeaderBarShouldDrawContainer(WidgetNodeType aNodeType) {
+  MOZ_ASSERT(aNodeType == MOZ_GTK_HEADER_BAR ||
+             aNodeType == MOZ_GTK_HEADER_BAR_MAXIMIZED);
+  mozilla::Unused << GetWidget(aNodeType);
+  return aNodeType == MOZ_GTK_HEADER_BAR
+             ? gHeaderBarShouldDrawContainer
+             : gMaximizedHeaderBarShouldDrawContainer;
+}
+
+gint GetBorderRadius(GtkStyleContext* aStyle) {
+  GValue value = G_VALUE_INIT;
+  // NOTE(emilio): In an ideal world, we'd query the two longhands
+  // (border-top-left-radius and border-top-right-radius) separately. However,
+  // that doesn't work (GTK rejects the query with:
+  //
+  //   Style property "border-top-left-radius" is not gettable
+  //
+  // However! Getting border-radius does work, and it does return the
+  // border-top-left-radius as a gint:
+  //
+  //   https://docs.gtk.org/gtk3/const.STYLE_PROPERTY_BORDER_RADIUS.html
+  //   https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-3-20/gtk/gtkcssshorthandpropertyimpl.c#L961-977
+  //
+  // So we abuse this fact, and make the assumption here that the
+  // border-top-{left,right}-radius are the same, and roll with it.
+  gtk_style_context_get_property(aStyle, "border-radius", GTK_STATE_FLAG_NORMAL,
+                                 &value);
+  gint result = 0;
+  auto type = G_VALUE_TYPE(&value);
+  if (type == G_TYPE_INT) {
+    result = g_value_get_int(&value);
+  } else {
+    NS_WARNING(nsPrintfCString("Unknown value type %lu for border-radius", type)
+                   .get());
+  }
+  g_value_unset(&value);
+  return result;
+}
diff --git a/widget/gtk/WidgetStyleCache.h b/widget/gtk/WidgetStyleCache.h
new file mode 100644
index 0000000000..f38b75fae6
--- /dev/null
+++ b/widget/gtk/WidgetStyleCache.h
@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WidgetStyleCache_h
+#define WidgetStyleCache_h
+
+#include <gtk/gtk.h>
+#include "gtkdrawing.h"
+
+GtkWidget* GetWidget(WidgetNodeType aNodeType);
+
+cairo_surface_t* GetWidgetIconSurface(GtkWidget* aWidgetIcon, int aScale);
+
+/*
+ * Return a new style context based on aWidget, as a child of aParentStyle.
+ * If aWidget still has a floating reference, then it is sunk and released.
+ */
+GtkStyleContext* CreateStyleForWidget(GtkWidget* aWidget,
+                                      GtkStyleContext* aParentStyle);
+
+GtkStyleContext* CreateCSSNode(const char* aName, GtkStyleContext* aParentStyle,
+                               GType aType = G_TYPE_NONE);
+
+/*
+ * Returns a pointer to a style context for the specified node and state.
+ * aStateFlags is applied only to last widget in css style path,
+ * for instance GetStyleContext(MOZ_GTK_BUTTON, .., GTK_STATE_FLAG_HOVER)
+ * you get "window button:hover" css selector.
+ * If you want aStateFlags applied to all path elements use
+ * CreateStyleContextWithStates().
+ *
+ * The context is owned by WidgetStyleCache. Do not unref.
+ */
+GtkStyleContext* GetStyleContext(
+    WidgetNodeType aNodeType, int aScale = 1,
+    GtkTextDirection aDirection = GTK_TEXT_DIR_NONE,
+    GtkStateFlags aStateFlags = GTK_STATE_FLAG_NORMAL);
+
+/*
+ * Returns a pointer to a style context for the specified node
+ * and state applied to all elements at widget style path.
+ *
+ * The context is owned by caller and must be released by g_object_unref().
+ */
+GtkStyleContext* CreateStyleContextWithStates(
+    WidgetNodeType aNodeType, int aScale = 1,
+    GtkTextDirection aDirection = GTK_TEXT_DIR_NONE,
+    GtkStateFlags aStateFlags = GTK_STATE_FLAG_NORMAL);
+
+void ResetWidgetCache();
+
+bool IsSolidCSDStyleUsed();
+
+void StyleContextSetScale(GtkStyleContext* style, gint aScaleFactor);
+
+gint GetBorderRadius(GtkStyleContext* aStyle);
+
+bool HeaderBarShouldDrawContainer(WidgetNodeType);
+
+#endif  // WidgetStyleCache_h
diff --git a/widget/gtk/WidgetTraceEvent.cpp b/widget/gtk/WidgetTraceEvent.cpp
new file mode 100644
index 0000000000..161e5302cc
--- /dev/null
+++ b/widget/gtk/WidgetTraceEvent.cpp
@@ -0,0 +1,68 @@
+/* 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 "mozilla/WidgetTraceEvent.h"
+
+#include <glib.h>
+#include <mozilla/CondVar.h>
+#include <mozilla/Mutex.h>
+#include <stdio.h>
+
+using mozilla::CondVar;
+using mozilla::Mutex;
+using mozilla::MutexAutoLock;
+
+namespace {
+
+Mutex* sMutex = nullptr;
+CondVar* sCondVar = nullptr;
+bool sTracerProcessed = false;
+
+// This function is called from the main (UI) thread.
+gboolean TracerCallback(gpointer data) {
+  mozilla::SignalTracerThread();
+  return FALSE;
+}
+
+}  // namespace
+
+namespace mozilla {
+
+bool InitWidgetTracing() {
+  sMutex = new Mutex("Event tracer thread mutex");
+  sCondVar = new CondVar(*sMutex, "Event tracer thread condvar");
+  return true;
+}
+
+void CleanUpWidgetTracing() {
+  delete sMutex;
+  delete sCondVar;
+  sMutex = nullptr;
+  sCondVar = nullptr;
+}
+
+// This function is called from the background tracer thread.
+bool FireAndWaitForTracerEvent() {
+  MOZ_ASSERT(sMutex && sCondVar, "Tracing not initialized!");
+
+  // Send a default-priority idle event through the
+  // event loop, and wait for it to finish.
+  MutexAutoLock lock(*sMutex);
+  MOZ_ASSERT(!sTracerProcessed, "Tracer synchronization state is wrong");
+  g_idle_add_full(G_PRIORITY_DEFAULT, TracerCallback, nullptr, nullptr);
+  while (!sTracerProcessed) sCondVar->Wait();
+  sTracerProcessed = false;
+  return true;
+}
+
+void SignalTracerThread() {
+  if (!sMutex || !sCondVar) return;
+  MutexAutoLock lock(*sMutex);
+  if (!sTracerProcessed) {
+    sTracerProcessed = true;
+    sCondVar->Notify();
+  }
+}
+
+}  // namespace mozilla
diff --git a/widget/gtk/WidgetUtilsGtk.cpp b/widget/gtk/WidgetUtilsGtk.cpp
new file mode 100644
index 0000000000..29368b3823
--- /dev/null
+++ b/widget/gtk/WidgetUtilsGtk.cpp
@@ -0,0 +1,446 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WidgetUtilsGtk.h"
+
+#include "MainThreadUtils.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/UniquePtr.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsWindow.h"
+#include "nsIGfxInfo.h"
+#include "mozilla/Components.h"
+#include "nsGtkKeyUtils.h"
+#include "nsGtkUtils.h"
+
+#include <gtk/gtk.h>
+#include <dlfcn.h>
+#include <glib.h>
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+extern mozilla::LazyLogModule gWidgetLog;
+#  define LOGW(...) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#else
+#  define LOGW(...)
+#endif /* MOZ_LOGGING */
+
+namespace mozilla::widget {
+
+int32_t WidgetUtilsGTK::IsTouchDeviceSupportPresent() {
+  int32_t result = 0;
+  GdkDisplay* display = gdk_display_get_default();
+  if (!display) {
+    return 0;
+  }
+
+  GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+  if (!manager) {
+    return 0;
+  }
+
+  GList* devices =
+      gdk_device_manager_list_devices(manager, GDK_DEVICE_TYPE_SLAVE);
+  GList* list = devices;
+
+  while (devices) {
+    GdkDevice* device = static_cast<GdkDevice*>(devices->data);
+    if (gdk_device_get_source(device) == GDK_SOURCE_TOUCHSCREEN) {
+      result = 1;
+      break;
+    }
+    devices = devices->next;
+  }
+
+  if (list) {
+    g_list_free(list);
+  }
+
+  return result;
+}
+
+bool IsMainWindowTransparent() {
+  return nsWindow::IsToplevelWindowTransparent();
+}
+
+// We avoid linking gdk_*_display_get_type directly in order to avoid a runtime
+// dependency on GTK built with both backends. Other X11- and Wayland-specific
+// functions get stubbed out by libmozgtk and crash when called, but those
+// should only be called when the matching backend is already in use.
+
+bool GdkIsWaylandDisplay(GdkDisplay* display) {
+  static auto sGdkWaylandDisplayGetType =
+      (GType(*)())dlsym(RTLD_DEFAULT, "gdk_wayland_display_get_type");
+  return sGdkWaylandDisplayGetType &&
+         G_TYPE_CHECK_INSTANCE_TYPE(display, sGdkWaylandDisplayGetType());
+}
+
+bool GdkIsX11Display(GdkDisplay* display) {
+  static auto sGdkX11DisplayGetType =
+      (GType(*)())dlsym(RTLD_DEFAULT, "gdk_x11_display_get_type");
+  return sGdkX11DisplayGetType &&
+         G_TYPE_CHECK_INSTANCE_TYPE(display, sGdkX11DisplayGetType());
+}
+
+bool IsXWaylandProtocol() {
+  static bool isXwayland = [] {
+    return !GdkIsWaylandDisplay() && !!getenv("WAYLAND_DISPLAY");
+  }();
+  return isXwayland;
+}
+
+bool GdkIsWaylandDisplay() {
+  static bool isWaylandDisplay = gdk_display_get_default() &&
+                                 GdkIsWaylandDisplay(gdk_display_get_default());
+  return isWaylandDisplay;
+}
+
+bool GdkIsX11Display() {
+  static bool isX11Display = gdk_display_get_default()
+                                 ? GdkIsX11Display(gdk_display_get_default())
+                                 : false;
+  return isX11Display;
+}
+
+GdkDevice* GdkGetPointer() {
+  GdkDisplay* display = gdk_display_get_default();
+  GdkDeviceManager* deviceManager = gdk_display_get_device_manager(display);
+  return gdk_device_manager_get_client_pointer(deviceManager);
+}
+
+static GdkEvent* sLastMousePressEvent = nullptr;
+GdkEvent* GetLastMousePressEvent() { return sLastMousePressEvent; }
+
+void SetLastMousePressEvent(GdkEvent* aEvent) {
+  if (sLastMousePressEvent) {
+    GUniquePtr<GdkEvent> event(sLastMousePressEvent);
+    sLastMousePressEvent = nullptr;
+  }
+  if (!aEvent) {
+    return;
+  }
+  GUniquePtr<GdkEvent> event(gdk_event_copy(aEvent));
+  sLastMousePressEvent = event.release();
+}
+
+bool IsRunningUnderSnap() { return g_getenv("SNAP_INSTANCE_NAME") != nullptr; }
+
+bool IsRunningUnderFlatpak() {
+  // https://gitlab.gnome.org/GNOME/gtk/-/blob/4300a5c609306ce77cbc8a3580c19201dccd8d13/gdk/gdk.c#L472
+  static bool sRunning = [] {
+    return g_file_test("/.flatpak-info", G_FILE_TEST_EXISTS);
+  }();
+  return sRunning;
+}
+
+const char* GetSnapInstanceName() {
+  static const char* sInstanceName = []() -> const char* {
+    // Intentionally leaked, as keeping a pointer to the environment forever is
+    // a bit suspicious.
+    if (const char* instanceName = g_getenv("SNAP_INSTANCE_NAME")) {
+      return g_strdup(instanceName);
+    }
+    // Compatibility for snapd <= 2.35:
+    if (const char* instanceName = g_getenv("SNAP_NAME")) {
+      return g_strdup(instanceName);
+    }
+    return nullptr;
+  }();
+
+  return sInstanceName;
+}
+
+bool ShouldUsePortal(PortalKind aPortalKind) {
+  static bool sPortalEnv = [] {
+    if (IsRunningUnderFlatpakOrSnap()) {
+      return true;
+    }
+    const char* portalEnvString = g_getenv("GTK_USE_PORTAL");
+    return portalEnvString && atoi(portalEnvString) != 0;
+  }();
+
+  bool autoBehavior = sPortalEnv;
+  const int32_t pref = [&] {
+    switch (aPortalKind) {
+      case PortalKind::FilePicker:
+        return StaticPrefs::widget_use_xdg_desktop_portal_file_picker();
+      case PortalKind::MimeHandler:
+        // Mime portal breaks default browser handling, see bug 1516290.
+        autoBehavior = IsRunningUnderFlatpakOrSnap();
+        return StaticPrefs::widget_use_xdg_desktop_portal_mime_handler();
+      case PortalKind::Settings:
+        autoBehavior = true;
+        return StaticPrefs::widget_use_xdg_desktop_portal_settings();
+      case PortalKind::Location:
+        return StaticPrefs::widget_use_xdg_desktop_portal_location();
+      case PortalKind::OpenUri:
+        return StaticPrefs::widget_use_xdg_desktop_portal_open_uri();
+    }
+    return 2;
+  }();
+
+  switch (pref) {
+    case 0:
+      return false;
+    case 1:
+      return true;
+    default:
+      return autoBehavior;
+  }
+}
+
+nsTArray<nsCString> ParseTextURIList(const nsACString& aData) {
+  UniquePtr<char[]> data(ToNewCString(aData));
+  gchar** uris = g_uri_list_extract_uris(data.get());
+
+  nsTArray<nsCString> result;
+  for (size_t i = 0; i < g_strv_length(uris); i++) {
+    result.AppendElement(nsCString(uris[i]));
+  }
+
+  g_strfreev(uris);
+  return result;
+}
+
+#ifdef MOZ_WAYLAND
+static gboolean token_failed(gpointer aData);
+
+class XDGTokenRequest {
+ public:
+  void SetTokenID(const char* aTokenID) {
+    mTransferPromise->Resolve(aTokenID, __func__);
+  }
+  void Cancel() {
+    mTransferPromise->Reject(false, __func__);
+    mActivationTimeoutID = 0;
+  }
+
+  XDGTokenRequest(xdg_activation_token_v1* aXdgToken,
+                  RefPtr<FocusRequestPromise::Private> aTransferPromise)
+      : mXdgToken(aXdgToken), mTransferPromise(std::move(aTransferPromise)) {
+    mActivationTimeoutID =
+        g_timeout_add(sActivationTimeout, token_failed, this);
+  }
+  ~XDGTokenRequest() {
+    MozClearPointer(mXdgToken, xdg_activation_token_v1_destroy);
+    if (mActivationTimeoutID) {
+      g_source_remove(mActivationTimeoutID);
+    }
+  }
+
+ private:
+  xdg_activation_token_v1* mXdgToken;
+  RefPtr<FocusRequestPromise::Private> mTransferPromise;
+  guint mActivationTimeoutID;
+  // Reject FocusRequestPromise if we don't get XDG token in 0.5 sec.
+  static constexpr int sActivationTimeout = 500;
+};
+
+// Failed to get token in time
+static gboolean token_failed(gpointer data) {
+  UniquePtr<XDGTokenRequest> request(static_cast<XDGTokenRequest*>(data));
+  request->Cancel();
+  return false;
+}
+
+// We've got activation token from Wayland compositor so it's time to use it.
+static void token_done(gpointer data, struct xdg_activation_token_v1* provider,
+                       const char* tokenID) {
+  UniquePtr<XDGTokenRequest> request(static_cast<XDGTokenRequest*>(data));
+  request->SetTokenID(tokenID);
+}
+
+static const struct xdg_activation_token_v1_listener token_listener = {
+    token_done,
+};
+#endif
+
+RefPtr<FocusRequestPromise> RequestWaylandFocusPromise() {
+#ifdef MOZ_WAYLAND
+  if (!GdkIsWaylandDisplay() || !nsWindow::GetFocusedWindow() ||
+      nsWindow::GetFocusedWindow()->IsDestroyed()) {
+    return nullptr;
+  }
+
+  RefPtr<nsWindow> sourceWindow = nsWindow::GetFocusedWindow();
+  if (!sourceWindow) {
+    return nullptr;
+  }
+
+  RefPtr<nsWaylandDisplay> display = WaylandDisplayGet();
+  xdg_activation_v1* xdg_activation = display->GetXdgActivation();
+  if (!xdg_activation) {
+    return nullptr;
+  }
+
+  wl_surface* focusSurface;
+  uint32_t focusSerial;
+  KeymapWrapper::GetFocusInfo(&focusSurface, &focusSerial);
+  if (!focusSurface) {
+    return nullptr;
+  }
+
+  GdkWindow* gdkWindow = gtk_widget_get_window(sourceWindow->GetGtkWidget());
+  if (!gdkWindow) {
+    return nullptr;
+  }
+  wl_surface* surface = gdk_wayland_window_get_wl_surface(gdkWindow);
+  if (focusSurface != surface) {
+    return nullptr;
+  }
+
+  RefPtr<FocusRequestPromise::Private> transferPromise =
+      new FocusRequestPromise::Private(__func__);
+
+  xdg_activation_token_v1* aXdgToken =
+      xdg_activation_v1_get_activation_token(xdg_activation);
+  xdg_activation_token_v1_add_listener(
+      aXdgToken, &token_listener,
+      new XDGTokenRequest(aXdgToken, transferPromise));
+  xdg_activation_token_v1_set_serial(aXdgToken, focusSerial,
+                                     KeymapWrapper::GetSeat());
+  xdg_activation_token_v1_set_surface(aXdgToken, focusSurface);
+  xdg_activation_token_v1_commit(aXdgToken);
+
+  return transferPromise.forget();
+#else  // !defined(MOZ_WAYLAND)
+  return nullptr;
+#endif
+}
+
+// https://specifications.freedesktop.org/wm-spec/1.3/ar01s05.html
+static nsCString GetWindowManagerName() {
+  if (!GdkIsX11Display()) {
+    return {};
+  }
+
+#ifdef MOZ_X11
+  Display* xdisplay = gdk_x11_get_default_xdisplay();
+  Window root_win =
+      GDK_WINDOW_XID(gdk_screen_get_root_window(gdk_screen_get_default()));
+
+  int actual_format_return;
+  Atom actual_type_return;
+  unsigned long nitems_return;
+  unsigned long bytes_after_return;
+  unsigned char* prop_return = nullptr;
+  auto releaseXProperty = MakeScopeExit([&] {
+    if (prop_return) {
+      XFree(prop_return);
+    }
+  });
+
+  Atom property = XInternAtom(xdisplay, "_NET_SUPPORTING_WM_CHECK", true);
+  Atom req_type = XInternAtom(xdisplay, "WINDOW", true);
+  if (!property || !req_type) {
+    return {};
+  }
+  int result =
+      XGetWindowProperty(xdisplay, root_win, property,
+                         0L,                  // offset
+                         sizeof(Window) / 4,  // length
+                         false,               // delete
+                         req_type, &actual_type_return, &actual_format_return,
+                         &nitems_return, &bytes_after_return, &prop_return);
+
+  if (result != Success || bytes_after_return != 0 || nitems_return != 1) {
+    return {};
+  }
+
+  Window wmWindow = reinterpret_cast<Window*>(prop_return)[0];
+  if (!wmWindow) {
+    return {};
+  }
+
+  XFree(prop_return);
+  prop_return = nullptr;
+
+  property = XInternAtom(xdisplay, "_NET_WM_NAME", true);
+  req_type = XInternAtom(xdisplay, "UTF8_STRING", true);
+  if (!property || !req_type) {
+    return {};
+  }
+  result =
+      XGetWindowProperty(xdisplay, wmWindow, property,
+                         0L,         // offset
+                         INT32_MAX,  // length
+                         false,      // delete
+                         req_type, &actual_type_return, &actual_format_return,
+                         &nitems_return, &bytes_after_return, &prop_return);
+  if (result != Success || bytes_after_return != 0) {
+    return {};
+  }
+
+  return nsCString(reinterpret_cast<const char*>(prop_return));
+#else
+  return {};
+#endif
+}
+
+// Getting a reliable identifier is quite tricky. We try to use the standard
+// XDG_CURRENT_DESKTOP environment first, _NET_WM_NAME later, and a set of
+// legacy / non-standard environment variables otherwise.
+//
+// Documentation for some of those can be found in:
+//
+// https://wiki.archlinux.org/title/Environment_variables#Examples
+// https://wiki.archlinux.org/title/Xdg-utils#Environment_variables
+const nsCString& GetDesktopEnvironmentIdentifier() {
+  MOZ_ASSERT(NS_IsMainThread());
+  static const nsDependentCString sIdentifier = [] {
+    nsCString ident = [] {
+      if (const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP")) {
+        return nsCString(currentDesktop);
+      }
+      if (auto wm = GetWindowManagerName(); !wm.IsEmpty()) {
+        return wm;
+      }
+      if (const char* sessionDesktop = getenv("XDG_SESSION_DESKTOP")) {
+        // This is not really standardized in freedesktop.org, but it is
+        // documented here, and should be set in systemd systems.
+        // https://www.freedesktop.org/software/systemd/man/pam_systemd.html#%24XDG_SESSION_DESKTOP
+        return nsCString(sessionDesktop);
+      }
+      // We try first the DE-specific variables, then SESSION_DESKTOP, to match
+      // the documented order in:
+      // https://wiki.archlinux.org/title/Xdg-utils#Environment_variables
+      if (getenv("GNOME_DESKTOP_SESSION_ID")) {
+        return nsCString("gnome"_ns);
+      }
+      if (getenv("KDE_FULL_SESSION")) {
+        return nsCString("kde"_ns);
+      }
+      if (getenv("MATE_DESKTOP_SESSION_ID")) {
+        return nsCString("mate"_ns);
+      }
+      if (getenv("LXQT_SESSION_CONFIG")) {
+        return nsCString("lxqt"_ns);
+      }
+      if (const char* desktopSession = getenv("DESKTOP_SESSION")) {
+        // Try the legacy DESKTOP_SESSION as a last resort.
+        return nsCString(desktopSession);
+      }
+      return nsCString();
+    }();
+    ToLowerCase(ident);
+    // Intentionally put into a ToNewCString copy, rather than just making a
+    // static nsCString to avoid leakchecking errors, since we really want to
+    // leak this string.
+    return nsDependentCString(ToNewCString(ident), ident.Length());
+  }();
+  return sIdentifier;
+}
+
+bool IsGnomeDesktopEnvironment() {
+  return FindInReadable("gnome"_ns, GetDesktopEnvironmentIdentifier());
+}
+
+bool IsKdeDesktopEnvironment() {
+  return GetDesktopEnvironmentIdentifier().EqualsLiteral("kde");
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/WidgetUtilsGtk.h b/widget/gtk/WidgetUtilsGtk.h
new file mode 100644
index 0000000000..590cafe1cc
--- /dev/null
+++ b/widget/gtk/WidgetUtilsGtk.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WidgetUtilsGtk_h__
+#define WidgetUtilsGtk_h__
+
+#include "nsString.h"
+#include "nsTArray.h"
+#include "mozilla/MozPromise.h"
+
+#include <stdint.h>
+
+typedef struct _GdkDisplay GdkDisplay;
+typedef struct _GdkDevice GdkDevice;
+typedef union _GdkEvent GdkEvent;
+class nsWindow;
+
+namespace mozilla::widget {
+
+class WidgetUtilsGTK {
+ public:
+  /* See WidgetUtils::IsTouchDeviceSupportPresent(). */
+  static int32_t IsTouchDeviceSupportPresent();
+};
+
+bool IsMainWindowTransparent();
+
+bool GdkIsWaylandDisplay(GdkDisplay* display);
+bool GdkIsX11Display(GdkDisplay* display);
+
+bool GdkIsWaylandDisplay();
+bool GdkIsX11Display();
+
+bool IsXWaylandProtocol();
+
+GdkDevice* GdkGetPointer();
+
+// Sets / returns the last mouse press event we processed.
+void SetLastMousePressEvent(GdkEvent*);
+GdkEvent* GetLastMousePressEvent();
+
+// Return the snap's instance name, or null when not running as a snap.
+const char* GetSnapInstanceName();
+bool IsRunningUnderSnap();
+bool IsRunningUnderFlatpak();
+inline bool IsRunningUnderFlatpakOrSnap() {
+  return IsRunningUnderFlatpak() || IsRunningUnderSnap();
+}
+
+enum class PortalKind {
+  FilePicker,
+  MimeHandler,
+  Settings,
+  Location,
+  OpenUri,
+};
+bool ShouldUsePortal(PortalKind);
+
+// Tries to get a descriptive identifier for the desktop environment that the
+// program is running under. Always normalized to lowercase.
+// See the implementation for the different environment variables and desktop
+// information we try to use.
+//
+// If we can't find a reasonable environment, the empty string is returned.
+const nsCString& GetDesktopEnvironmentIdentifier();
+bool IsGnomeDesktopEnvironment();
+bool IsKdeDesktopEnvironment();
+
+// Parse text/uri-list
+nsTArray<nsCString> ParseTextURIList(const nsACString& data);
+
+using FocusRequestPromise = MozPromise<nsCString, bool, false>;
+RefPtr<FocusRequestPromise> RequestWaylandFocusPromise();
+
+}  // namespace mozilla::widget
+
+#endif  // WidgetUtilsGtk_h__
diff --git a/widget/gtk/WindowSurface.h b/widget/gtk/WindowSurface.h
new file mode 100644
index 0000000000..858ddde59e
--- /dev/null
+++ b/widget/gtk/WindowSurface.h
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_WINDOW_SURFACE_H
+#define _MOZILLA_WIDGET_WINDOW_SURFACE_H
+
+#include "mozilla/gfx/2D.h"
+#include "Units.h"
+
+namespace mozilla {
+namespace widget {
+
+// A class for drawing to double-buffered windows.
+class WindowSurface {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WindowSurface);
+
+  // Locks a region of the window for drawing, returning a draw target
+  // capturing the bounds of the provided region.
+  // Implementations must permit invocation from any thread.
+  virtual already_AddRefed<gfx::DrawTarget> Lock(
+      const LayoutDeviceIntRegion& aRegion) = 0;
+
+  // Swaps the provided invalid region from the back buffer to the window.
+  // Implementations must permit invocation from any thread.
+  virtual void Commit(const LayoutDeviceIntRegion& aInvalidRegion) = 0;
+
+  // Whether the window surface represents a fallback method.
+  virtual bool IsFallback() const { return false; }
+
+ protected:
+  virtual ~WindowSurface() = default;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // _MOZILLA_WIDGET_WINDOW_SURFACE_H
diff --git a/widget/gtk/WindowSurfaceProvider.cpp b/widget/gtk/WindowSurfaceProvider.cpp
new file mode 100644
index 0000000000..f8eee65cc5
--- /dev/null
+++ b/widget/gtk/WindowSurfaceProvider.cpp
@@ -0,0 +1,200 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WindowSurfaceProvider.h"
+
+#include "gfxPlatformGtk.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "nsWindow.h"
+
+#ifdef MOZ_WAYLAND
+#  include "mozilla/StaticPrefs_widget.h"
+#  include "WindowSurfaceWaylandMultiBuffer.h"
+#endif
+#ifdef MOZ_X11
+#  include "mozilla/X11Util.h"
+#  include "WindowSurfaceX11Image.h"
+#  include "WindowSurfaceX11SHM.h"
+#endif
+
+#undef LOG
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gWidgetLog;
+#  define LOG(args) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, args)
+#else
+#  define LOG(args)
+#endif /* MOZ_LOGGING */
+
+namespace mozilla {
+namespace widget {
+
+using namespace mozilla::layers;
+
+WindowSurfaceProvider::WindowSurfaceProvider()
+    : mWindowSurface(nullptr),
+      mMutex("WindowSurfaceProvider"),
+      mWindowSurfaceValid(false)
+#ifdef MOZ_WAYLAND
+      ,
+      mWidget(nullptr)
+#endif
+#ifdef MOZ_X11
+      ,
+      mIsShaped(false),
+      mXDepth(0),
+      mXWindow(0),
+      mXVisual(nullptr)
+#endif
+{
+}
+
+#ifdef MOZ_WAYLAND
+void WindowSurfaceProvider::Initialize(RefPtr<nsWindow> aWidget) {
+  mWindowSurfaceValid = false;
+  mWidget = std::move(aWidget);
+}
+#endif
+#ifdef MOZ_X11
+void WindowSurfaceProvider::Initialize(Window aWindow, Visual* aVisual,
+                                       int aDepth, bool aIsShaped) {
+  mWindowSurfaceValid = false;
+  mXWindow = aWindow;
+  mXVisual = aVisual;
+  mXDepth = aDepth;
+  mIsShaped = aIsShaped;
+}
+#endif
+
+void WindowSurfaceProvider::CleanupResources() {
+  MutexAutoLock lock(mMutex);
+  mWindowSurfaceValid = false;
+#ifdef MOZ_WAYLAND
+  mWidget = nullptr;
+#endif
+#ifdef MOZ_X11
+  mXWindow = 0;
+  mXVisual = 0;
+  mXDepth = 0;
+  mIsShaped = false;
+#endif
+}
+
+RefPtr<WindowSurface> WindowSurfaceProvider::CreateWindowSurface() {
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay()) {
+    // We're called too early or we're unmapped.
+    if (!mWidget) {
+      return nullptr;
+    }
+    return MakeRefPtr<WindowSurfaceWaylandMB>(mWidget);
+  }
+#endif
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    // We're called too early or we're unmapped.
+    if (!mXWindow) {
+      return nullptr;
+    }
+    // Blit to the window with the following priority:
+    // 1. MIT-SHM
+    // 2. XPutImage
+#  ifdef MOZ_HAVE_SHMIMAGE
+    if (!mIsShaped && nsShmImage::UseShm()) {
+      LOG(("Drawing to Window 0x%lx will use MIT-SHM\n", mXWindow));
+      return MakeRefPtr<WindowSurfaceX11SHM>(DefaultXDisplay(), mXWindow,
+                                             mXVisual, mXDepth);
+    }
+#  endif  // MOZ_HAVE_SHMIMAGE
+
+    LOG(("Drawing to Window 0x%lx will use XPutImage\n", mXWindow));
+    return MakeRefPtr<WindowSurfaceX11Image>(DefaultXDisplay(), mXWindow,
+                                             mXVisual, mXDepth, mIsShaped);
+  }
+#endif
+  MOZ_RELEASE_ASSERT(false);
+}
+
+already_AddRefed<gfx::DrawTarget>
+WindowSurfaceProvider::StartRemoteDrawingInRegion(
+    const LayoutDeviceIntRegion& aInvalidRegion,
+    layers::BufferMode* aBufferMode) {
+  if (aInvalidRegion.IsEmpty()) {
+    return nullptr;
+  }
+
+  MutexAutoLock lock(mMutex);
+
+  if (!mWindowSurfaceValid) {
+    mWindowSurface = nullptr;
+    mWindowSurfaceValid = true;
+  }
+
+  if (!mWindowSurface) {
+    mWindowSurface = CreateWindowSurface();
+    if (!mWindowSurface) {
+      return nullptr;
+    }
+  }
+
+  *aBufferMode = BufferMode::BUFFER_NONE;
+  RefPtr<gfx::DrawTarget> dt = mWindowSurface->Lock(aInvalidRegion);
+#ifdef MOZ_X11
+  if (!dt && GdkIsX11Display() && !mWindowSurface->IsFallback()) {
+    // We can't use WindowSurfaceX11Image fallback on Wayland but
+    // Lock() call on WindowSurfaceWayland should never fail.
+    gfxWarningOnce()
+        << "Failed to lock WindowSurface, falling back to XPutImage backend.";
+    mWindowSurface = MakeRefPtr<WindowSurfaceX11Image>(
+        DefaultXDisplay(), mXWindow, mXVisual, mXDepth, mIsShaped);
+    dt = mWindowSurface->Lock(aInvalidRegion);
+  }
+#endif
+  return dt.forget();
+}
+
+void WindowSurfaceProvider::EndRemoteDrawingInRegion(
+    gfx::DrawTarget* aDrawTarget, const LayoutDeviceIntRegion& aInvalidRegion) {
+  MutexAutoLock lock(mMutex);
+  // Commit to mWindowSurface only if we have a valid one.
+  if (!mWindowSurface || !mWindowSurfaceValid) {
+    return;
+  }
+#if defined(MOZ_WAYLAND)
+  if (GdkIsWaylandDisplay()) {
+    // We're called too early or we're unmapped.
+    // Don't draw anything.
+    if (!mWidget || !mWidget->IsMapped()) {
+      return;
+    }
+    if (moz_container_wayland_is_commiting_to_parent(
+            mWidget->GetMozContainer())) {
+      // If we're drawing directly to wl_surface owned by Gtk we need to use it
+      // in main thread to sync with Gtk access to it.
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "WindowSurfaceProvider::EndRemoteDrawingInRegion",
+          [widget = RefPtr{mWidget}, this, aInvalidRegion]() {
+            if (!widget->IsMapped()) {
+              return;
+            }
+            MutexAutoLock lock(mMutex);
+            // Commit to mWindowSurface only when we have a valid one.
+            if (mWindowSurface && mWindowSurfaceValid) {
+              mWindowSurface->Commit(aInvalidRegion);
+            }
+          }));
+      return;
+    }
+  }
+#endif
+  mWindowSurface->Commit(aInvalidRegion);
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/WindowSurfaceProvider.h b/widget/gtk/WindowSurfaceProvider.h
new file mode 100644
index 0000000000..a0d6315591
--- /dev/null
+++ b/widget/gtk/WindowSurfaceProvider.h
@@ -0,0 +1,95 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_PROVIDER_H
+#define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_PROVIDER_H
+
+#include <gdk/gdk.h>
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/widget/WindowSurface.h"
+#include "Units.h"
+#include "mozilla/ScopeExit.h"
+
+#ifdef MOZ_X11
+#  include <X11/Xlib.h>  // for Window, Display, Visual, etc.
+#  include "X11UndefineNone.h"
+#endif
+
+class nsWindow;
+
+namespace mozilla {
+namespace widget {
+
+/*
+ * Holds the logic for creating WindowSurface's for a GTK nsWindow.
+ * The main purpose of this class is to allow sharing of logic between
+ * nsWindow and GtkCompositorWidget, for when OMTC is enabled or disabled.
+ */
+class WindowSurfaceProvider final {
+ public:
+  WindowSurfaceProvider();
+  ~WindowSurfaceProvider() = default;
+
+  /**
+   * Initializes the WindowSurfaceProvider by giving it the window
+   * handle and display to attach to. WindowSurfaceProvider doesn't
+   * own the Display, Window, etc, and they must continue to exist
+   * while WindowSurfaceProvider is used.
+   */
+#ifdef MOZ_WAYLAND
+  void Initialize(RefPtr<nsWindow> aWidget);
+#endif
+#ifdef MOZ_X11
+  void Initialize(Window aWindow, Visual* aVisual, int aDepth, bool aIsShaped);
+#endif
+
+  /**
+   * Releases any surfaces created by this provider.
+   * This is used by GtkCompositorWidget to get rid
+   * of resources.
+   */
+  void CleanupResources();
+
+  already_AddRefed<gfx::DrawTarget> StartRemoteDrawingInRegion(
+      const LayoutDeviceIntRegion& aInvalidRegion,
+      layers::BufferMode* aBufferMode);
+  void EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
+                                const LayoutDeviceIntRegion& aInvalidRegion);
+
+ private:
+  RefPtr<WindowSurface> CreateWindowSurface();
+  void CleanupWindowSurface();
+
+  RefPtr<WindowSurface> mWindowSurface;
+
+  /* While CleanupResources() can be called from Main thread when nsWindow is
+   * destroyed/hidden, StartRemoteDrawingInRegion()/EndRemoteDrawingInRegion()
+   * is called from Compositor thread during rendering.
+   *
+   * As nsWindow CleanupResources() call comes from Gtk/X11 we can't synchronize
+   * that with WebRender so we use lock to synchronize the access.
+   */
+  mozilla::Mutex mMutex MOZ_UNANNOTATED;
+  // WindowSurface needs to be re-created as underlying window was changed.
+  mozilla::Atomic<bool> mWindowSurfaceValid;
+#ifdef MOZ_WAYLAND
+  RefPtr<nsWindow> mWidget;
+#endif
+#ifdef MOZ_X11
+  bool mIsShaped;
+  int mXDepth;
+  Window mXWindow;
+  Visual* mXVisual;
+#endif
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_PROVIDER_H
diff --git a/widget/gtk/WindowSurfaceWaylandMultiBuffer.cpp b/widget/gtk/WindowSurfaceWaylandMultiBuffer.cpp
new file mode 100644
index 0000000000..0238bdb0e5
--- /dev/null
+++ b/widget/gtk/WindowSurfaceWaylandMultiBuffer.cpp
@@ -0,0 +1,390 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WindowSurfaceWaylandMultiBuffer.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <prenv.h>
+
+#include "gfx2DGlue.h"
+#include "gfxPlatform.h"
+#include "MozContainer.h"
+#include "mozilla/gfx/DataSurfaceHelpers.h"
+#include "mozilla/gfx/Tools.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/WidgetUtils.h"
+
+#undef LOG
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gWidgetWaylandLog;
+#  define LOGWAYLAND(...) \
+    MOZ_LOG(gWidgetWaylandLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#else
+#  define LOGWAYLAND(...)
+#endif /* MOZ_LOGGING */
+
+namespace mozilla::widget {
+
+/*
+  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.
+
+  ----------------------
+  | Wayland compositor |
+  ----------------------
+             ^
+             |
+  ----------------------
+  |  nsWaylandDisplay  |
+  ----------------------
+        ^          ^
+        |          |
+        |          |
+        |       ---------------------------------        ------------------
+        |       | WindowSurfaceWayland          |<------>| nsWindow       |
+        |       |                               |        ------------------
+        |       |  -----------------------      |
+        |       |  | WaylandBufferSHM    |      |
+        |       |  |                     |      |
+        |       |  | ------------------- |      |
+        |       |  | |  WaylandShmPool | |      |
+        |       |  | ------------------- |      |
+        |       |  -----------------------      |
+        |       |                               |
+        |       |  -----------------------      |
+        |       |  | WaylandBufferSHM    |      |
+        |       |  |                     |      |
+        |       |  | ------------------- |      |
+        |       |  | |  WaylandShmPool | |      |
+        |       |  | ------------------- |      |
+        |       |  -----------------------      |
+        |       ---------------------------------
+        |
+        |
+  ---------------------------------        ------------------
+  | WindowSurfaceWayland          |<------>| nsWindow       |
+  |                               |        ------------------
+  |  -----------------------      |
+  |  | WaylandBufferSHM    |      |
+  |  |                     |      |
+  |  | ------------------- |      |
+  |  | |  WaylandShmPool | |      |
+  |  | ------------------- |      |
+  |  -----------------------      |
+  |                               |
+  |  -----------------------      |
+  |  | WaylandBufferSHM    |      |
+  |  |                     |      |
+  |  | ------------------- |      |
+  |  | |  WaylandShmPool | |      |
+  |  | ------------------- |      |
+  |  -----------------------      |
+  ---------------------------------
+
+
+nsWaylandDisplay
+
+Is our connection to Wayland display server,
+holds our display connection (wl_display) and event queue (wl_event_queue).
+
+nsWaylandDisplay is created for every thread which sends data to Wayland
+compositor. Wayland events for main thread is served by default Gtk+ loop,
+for other threads (compositor) we must create wl_event_queue and run event loop.
+
+
+WindowSurfaceWayland
+
+Is a Wayland implementation of WindowSurface class for WindowSurfaceProvider,
+we implement Lock() and Commit() interfaces from WindowSurface
+for actual drawing.
+
+One WindowSurfaceWayland draws one nsWindow so those are tied 1:1.
+At Wayland level it holds one wl_surface object.
+
+To perform visualiation of nsWindow, WindowSurfaceWayland contains one
+wl_surface and two wl_buffer objects (owned by WaylandBufferSHM)
+as we use double buffering. When nsWindow drawing is finished to wl_buffer,
+the wl_buffer is attached to wl_surface and it's sent to Wayland compositor.
+
+When there's no wl_buffer available for drawing (all wl_buffers are locked in
+compositor for instance) we store the drawing to WindowImageSurface object
+and draw later when wl_buffer becomes available or discard the
+WindowImageSurface cache when whole screen is invalidated.
+
+WaylandBufferSHM
+
+Is a class which provides a wl_buffer for drawing.
+Wl_buffer is a main Wayland object with actual graphics data.
+Wl_buffer basically represent one complete window screen.
+When double buffering is involved every window (GdkWindow for instance)
+utilises two wl_buffers which are cycled. One is filed with data by application
+and one is rendered by compositor.
+
+WaylandBufferSHM is implemented by shared memory (shm).
+It owns wl_buffer object, owns WaylandShmPool
+(which provides the shared memory) and ties them together.
+
+WaylandShmPool
+
+WaylandShmPool acts as a manager of shared memory for WaylandBufferSHM.
+Allocates it, holds reference to it and releases it.
+
+We allocate shared memory (shm) by mmap(..., MAP_SHARED,...) as an interface
+between us and wayland compositor. We draw our graphics data to the shm and
+handle to wayland compositor by WaylandBufferSHM/WindowSurfaceWayland
+(wl_buffer/wl_surface).
+*/
+
+using gfx::DataSourceSurface;
+
+#define BACK_BUFFER_NUM 3
+
+WindowSurfaceWaylandMB::WindowSurfaceWaylandMB(RefPtr<nsWindow> aWindow)
+    : mSurfaceLock("WindowSurfaceWayland lock"),
+      mWindow(std::move(aWindow)),
+      mFrameInProcess(false),
+      mCallbackRequested(false) {}
+
+already_AddRefed<DrawTarget> WindowSurfaceWaylandMB::Lock(
+    const LayoutDeviceIntRegion& aInvalidRegion) {
+  MutexAutoLock lock(mSurfaceLock);
+
+#ifdef MOZ_LOGGING
+  gfx::IntRect lockRect = aInvalidRegion.GetBounds().ToUnknownRect();
+  LOGWAYLAND("WindowSurfaceWaylandMB::Lock [%p] [%d,%d] -> [%d x %d] rects %d",
+             (void*)mWindow.get(), lockRect.x, lockRect.y, lockRect.width,
+             lockRect.height, aInvalidRegion.GetNumRects());
+#endif
+
+  if (mWindow->WindowType() == eWindowType_invisible) {
+    return nullptr;
+  }
+  mFrameInProcess = true;
+
+  CollectPendingSurfaces(lock);
+
+  LayoutDeviceIntSize newMozContainerSize = mWindow->GetMozContainerSize();
+  if (mMozContainerSize != newMozContainerSize) {
+    mMozContainerSize = newMozContainerSize;
+    LOGWAYLAND("  new MozContainer size [%d x %d]", mMozContainerSize.width,
+               mMozContainerSize.height);
+    if (mInProgressBuffer) {
+      ReturnBufferToPool(lock, mInProgressBuffer);
+      mInProgressBuffer = nullptr;
+    }
+    if (mFrontBuffer) {
+      ReturnBufferToPool(lock, mFrontBuffer);
+      mFrontBuffer = nullptr;
+    }
+    mAvailableBuffers.Clear();
+  }
+
+  if (!mInProgressBuffer) {
+    if (mFrontBuffer && !mFrontBuffer->IsAttached()) {
+      mInProgressBuffer = mFrontBuffer;
+    } else {
+      mInProgressBuffer = ObtainBufferFromPool(lock, mMozContainerSize);
+      if (!mInProgressBuffer) {
+        return nullptr;
+      }
+      if (mFrontBuffer) {
+        HandlePartialUpdate(lock, aInvalidRegion);
+        ReturnBufferToPool(lock, mFrontBuffer);
+      }
+    }
+    mFrontBuffer = nullptr;
+    mFrontBufferInvalidRegion.SetEmpty();
+  }
+
+  RefPtr<DrawTarget> dt = mInProgressBuffer->Lock();
+  return dt.forget();
+}
+
+void WindowSurfaceWaylandMB::HandlePartialUpdate(
+    const MutexAutoLock& aProofOfLock,
+    const LayoutDeviceIntRegion& aInvalidRegion) {
+  LayoutDeviceIntRegion copyRegion;
+  if (mInProgressBuffer->GetBufferAge() == 2) {
+    copyRegion.Sub(mFrontBufferInvalidRegion, aInvalidRegion);
+  } else {
+    LayoutDeviceIntSize frontBufferSize = mFrontBuffer->GetSize();
+    copyRegion = LayoutDeviceIntRegion(LayoutDeviceIntRect(
+        0, 0, frontBufferSize.width, frontBufferSize.height));
+    copyRegion.SubOut(aInvalidRegion);
+  }
+
+  if (!copyRegion.IsEmpty()) {
+    RefPtr<DataSourceSurface> dataSourceSurface =
+        mozilla::gfx::CreateDataSourceSurfaceFromData(
+            mFrontBuffer->GetSize().ToUnknownSize(),
+            mFrontBuffer->GetSurfaceFormat(),
+            (const uint8_t*)mFrontBuffer->GetShmPool()->GetImageData(),
+            mFrontBuffer->GetSize().width *
+                BytesPerPixel(mFrontBuffer->GetSurfaceFormat()));
+    RefPtr<DrawTarget> dt = mInProgressBuffer->Lock();
+
+    for (auto iter = copyRegion.RectIter(); !iter.Done(); iter.Next()) {
+      LayoutDeviceIntRect r = iter.Get();
+      dt->CopySurface(dataSourceSurface, r.ToUnknownRect(),
+                      gfx::IntPoint(r.x, r.y));
+    }
+  }
+}
+
+void WindowSurfaceWaylandMB::Commit(
+    const LayoutDeviceIntRegion& aInvalidRegion) {
+  MutexAutoLock lock(mSurfaceLock);
+  Commit(lock, aInvalidRegion);
+}
+
+void WindowSurfaceWaylandMB::Commit(
+    const MutexAutoLock& aProofOfLock,
+    const LayoutDeviceIntRegion& aInvalidRegion) {
+#ifdef MOZ_LOGGING
+  gfx::IntRect invalidRect = aInvalidRegion.GetBounds().ToUnknownRect();
+  LOGWAYLAND(
+      "WindowSurfaceWaylandMB::Commit [%p] damage rect [%d, %d] -> [%d x %d] "
+      "MozContainer [%d x %d]\n",
+      (void*)mWindow.get(), invalidRect.x, invalidRect.y, invalidRect.width,
+      invalidRect.height, mMozContainerSize.width, mMozContainerSize.height);
+#endif
+
+  if (!mInProgressBuffer) {
+    // invisible window
+    return;
+  }
+  mFrameInProcess = false;
+
+  MozContainer* container = mWindow->GetMozContainer();
+  MozContainerSurfaceLock lock(container);
+  struct wl_surface* waylandSurface = lock.GetSurface();
+  if (!waylandSurface) {
+    LOGWAYLAND(
+        "WindowSurfaceWaylandMB::Commit [%p] frame queued: can't lock "
+        "wl_surface\n",
+        (void*)mWindow.get());
+    if (!mCallbackRequested) {
+      RefPtr<WindowSurfaceWaylandMB> self(this);
+      moz_container_wayland_add_initial_draw_callback_locked(
+          container, [self, aInvalidRegion]() -> void {
+            MutexAutoLock lock(self->mSurfaceLock);
+            if (!self->mFrameInProcess) {
+              self->Commit(lock, aInvalidRegion);
+            }
+            self->mCallbackRequested = false;
+          });
+      mCallbackRequested = true;
+    }
+    return;
+  }
+
+  if (moz_container_wayland_is_commiting_to_parent(container)) {
+    // When committing to parent surface we must use wl_surface_damage().
+    // A parent surface is created as v.3 object which does not support
+    // wl_surface_damage_buffer().
+    wl_surface_damage(waylandSurface, 0, 0, INT32_MAX, INT32_MAX);
+  } else {
+    for (auto iter = aInvalidRegion.RectIter(); !iter.Done(); iter.Next()) {
+      LayoutDeviceIntRect r = iter.Get();
+      wl_surface_damage_buffer(waylandSurface, r.x, r.y, r.width, r.height);
+    }
+  }
+
+  moz_container_wayland_set_scale_factor_locked(aProofOfLock, container);
+  mInProgressBuffer->AttachAndCommit(waylandSurface);
+
+  mInProgressBuffer->ResetBufferAge();
+  mFrontBuffer = mInProgressBuffer;
+  mFrontBufferInvalidRegion = aInvalidRegion;
+  mInProgressBuffer = nullptr;
+
+  EnforcePoolSizeLimit(aProofOfLock);
+  IncrementBufferAge(aProofOfLock);
+
+  if (wl_display_flush(WaylandDisplayGet()->GetDisplay()) == -1) {
+    LOGWAYLAND("WindowSurfaceWaylandMB::Commit [%p] flush failed\n",
+               (void*)mWindow.get());
+  }
+}
+
+RefPtr<WaylandBufferSHM> WindowSurfaceWaylandMB::ObtainBufferFromPool(
+    const MutexAutoLock& aProofOfLock, const LayoutDeviceIntSize& aSize) {
+  if (!mAvailableBuffers.IsEmpty()) {
+    RefPtr<WaylandBufferSHM> buffer = mAvailableBuffers.PopLastElement();
+    mInUseBuffers.AppendElement(buffer);
+    return buffer;
+  }
+
+  RefPtr<WaylandBufferSHM> buffer = WaylandBufferSHM::Create(aSize);
+  if (buffer) {
+    mInUseBuffers.AppendElement(buffer);
+  }
+
+  return buffer;
+}
+
+void WindowSurfaceWaylandMB::ReturnBufferToPool(
+    const MutexAutoLock& aProofOfLock,
+    const RefPtr<WaylandBufferSHM>& aBuffer) {
+  if (aBuffer->IsAttached()) {
+    mPendingBuffers.AppendElement(aBuffer);
+  } else if (aBuffer->IsMatchingSize(mMozContainerSize)) {
+    mAvailableBuffers.AppendElement(aBuffer);
+  }
+  mInUseBuffers.RemoveElement(aBuffer);
+}
+
+void WindowSurfaceWaylandMB::EnforcePoolSizeLimit(
+    const MutexAutoLock& aProofOfLock) {
+  // Enforce the pool size limit, removing least-recently-used entries as
+  // necessary.
+  while (mAvailableBuffers.Length() > BACK_BUFFER_NUM) {
+    mAvailableBuffers.RemoveElementAt(0);
+  }
+
+  NS_WARNING_ASSERTION(mPendingBuffers.Length() < BACK_BUFFER_NUM,
+                       "Are we leaking pending buffers?");
+  NS_WARNING_ASSERTION(mInUseBuffers.Length() < BACK_BUFFER_NUM,
+                       "Are we leaking in-use buffers?");
+}
+
+void WindowSurfaceWaylandMB::CollectPendingSurfaces(
+    const MutexAutoLock& aProofOfLock) {
+  mPendingBuffers.RemoveElementsBy([&](auto& buffer) {
+    if (!buffer->IsAttached()) {
+      if (buffer->IsMatchingSize(mMozContainerSize)) {
+        mAvailableBuffers.AppendElement(std::move(buffer));
+      }
+      return true;
+    }
+    return false;
+  });
+}
+
+void WindowSurfaceWaylandMB::IncrementBufferAge(
+    const MutexAutoLock& aProofOfLock) {
+  for (const RefPtr<WaylandBufferSHM>& buffer : mInUseBuffers) {
+    buffer->IncrementBufferAge();
+  }
+  for (const RefPtr<WaylandBufferSHM>& buffer : mPendingBuffers) {
+    buffer->IncrementBufferAge();
+  }
+  for (const RefPtr<WaylandBufferSHM>& buffer : mAvailableBuffers) {
+    buffer->IncrementBufferAge();
+  }
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/WindowSurfaceWaylandMultiBuffer.h b/widget/gtk/WindowSurfaceWaylandMultiBuffer.h
new file mode 100644
index 0000000000..3e26a1d5b1
--- /dev/null
+++ b/widget/gtk/WindowSurfaceWaylandMultiBuffer.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_MULTI_BUFFER_H
+#define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_MULTI_BUFFER_H
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/Mutex.h"
+#include "nsTArray.h"
+#include "nsWaylandDisplay.h"
+#include "nsWindow.h"
+#include "WaylandBuffer.h"
+#include "WindowSurface.h"
+
+namespace mozilla::widget {
+
+using gfx::DrawTarget;
+
+// WindowSurfaceWaylandMB is an abstraction for wl_surface
+// and related management
+class WindowSurfaceWaylandMB : public WindowSurface {
+ public:
+  explicit WindowSurfaceWaylandMB(RefPtr<nsWindow> aWindow);
+  ~WindowSurfaceWaylandMB() = default;
+
+  // Lock() / Commit() are called by gecko when Firefox
+  // wants to display something. Lock() returns a DrawTarget
+  // where gecko paints. When gecko is done it calls Commit()
+  // and we try to send the DrawTarget (backed by wl_buffer)
+  // to wayland compositor.
+  //
+  // If we fail (wayland compositor is busy,
+  // wl_surface is not created yet) we queue the painting
+  // and we send it to wayland compositor in FrameCallbackHandler()/
+  // FlushPendingCommits().
+  already_AddRefed<DrawTarget> Lock(
+      const LayoutDeviceIntRegion& aInvalidRegion) override;
+  void Commit(const LayoutDeviceIntRegion& aInvalidRegion) final;
+
+ private:
+  void Commit(const MutexAutoLock& aProofOfLock,
+              const LayoutDeviceIntRegion& aInvalidRegion);
+  RefPtr<WaylandBufferSHM> ObtainBufferFromPool(
+      const MutexAutoLock& aProofOfLock, const LayoutDeviceIntSize& aSize);
+  void ReturnBufferToPool(const MutexAutoLock& aProofOfLock,
+                          const RefPtr<WaylandBufferSHM>& aBuffer);
+  void EnforcePoolSizeLimit(const MutexAutoLock& aProofOfLock);
+  void CollectPendingSurfaces(const MutexAutoLock& aProofOfLock);
+  void HandlePartialUpdate(const MutexAutoLock& aProofOfLock,
+                           const LayoutDeviceIntRegion& aInvalidRegion);
+  void IncrementBufferAge(const MutexAutoLock& aProofOfLock);
+
+  mozilla::Mutex mSurfaceLock MOZ_UNANNOTATED;
+
+  RefPtr<nsWindow> mWindow;
+  LayoutDeviceIntSize mMozContainerSize;
+
+  RefPtr<WaylandBufferSHM> mInProgressBuffer;
+  RefPtr<WaylandBufferSHM> mFrontBuffer;
+  LayoutDeviceIntRegion mFrontBufferInvalidRegion;
+
+  // buffer pool
+  nsTArray<RefPtr<WaylandBufferSHM>> mInUseBuffers;
+  nsTArray<RefPtr<WaylandBufferSHM>> mPendingBuffers;
+  nsTArray<RefPtr<WaylandBufferSHM>> mAvailableBuffers;
+
+  // delayed commits
+  bool mFrameInProcess;
+  bool mCallbackRequested;
+};
+
+}  // namespace mozilla::widget
+
+#endif  // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_MULTI_BUFFER_H
diff --git a/widget/gtk/WindowSurfaceX11.cpp b/widget/gtk/WindowSurfaceX11.cpp
new file mode 100644
index 0000000000..36b238a98b
--- /dev/null
+++ b/widget/gtk/WindowSurfaceX11.cpp
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WindowSurfaceX11.h"
+#include "gfxPlatform.h"
+
+namespace mozilla::widget {
+
+WindowSurfaceX11::WindowSurfaceX11(Display* aDisplay, Window aWindow,
+                                   Visual* aVisual, unsigned int aDepth)
+    : mDisplay(aDisplay),
+      mWindow(aWindow),
+      mVisual(aVisual),
+      mDepth(aDepth),
+      mFormat(GetVisualFormat(aVisual, aDepth)) {}
+
+/* static */
+gfx::SurfaceFormat WindowSurfaceX11::GetVisualFormat(const Visual* aVisual,
+                                                     unsigned int aDepth) {
+  switch (aDepth) {
+    case 32:
+      if (aVisual->red_mask == 0xff0000 && aVisual->green_mask == 0xff00 &&
+          aVisual->blue_mask == 0xff) {
+        return gfx::SurfaceFormat::B8G8R8A8;
+      }
+      break;
+    case 24:
+      if (aVisual->red_mask == 0xff0000 && aVisual->green_mask == 0xff00 &&
+          aVisual->blue_mask == 0xff) {
+        return gfx::SurfaceFormat::B8G8R8X8;
+      }
+      break;
+    case 16:
+      if (aVisual->red_mask == 0xf800 && aVisual->green_mask == 0x07e0 &&
+          aVisual->blue_mask == 0x1f) {
+        return gfx::SurfaceFormat::R5G6B5_UINT16;
+      }
+      break;
+  }
+
+  return gfx::SurfaceFormat::UNKNOWN;
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/WindowSurfaceX11.h b/widget/gtk/WindowSurfaceX11.h
new file mode 100644
index 0000000000..dda17bf0d0
--- /dev/null
+++ b/widget/gtk/WindowSurfaceX11.h
@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_X11_H
+#define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_X11_H
+
+#ifdef MOZ_X11
+
+#  include "mozilla/widget/WindowSurface.h"
+#  include "mozilla/gfx/Types.h"
+
+#  include <X11/Xlib.h>
+#  include "X11UndefineNone.h"
+
+namespace mozilla::widget {
+
+class WindowSurfaceX11 : public WindowSurface {
+ public:
+  WindowSurfaceX11(Display* aDisplay, Window aWindow, Visual* aVisual,
+                   unsigned int aDepth);
+
+ protected:
+  static gfx::SurfaceFormat GetVisualFormat(const Visual* aVisual,
+                                            unsigned int aDepth);
+
+  Display* const mDisplay;
+  const Window mWindow;
+  Visual* const mVisual;
+  const unsigned int mDepth;
+  const gfx::SurfaceFormat mFormat;
+};
+
+}  // namespace mozilla::widget
+
+#endif  // MOZ_X11
+#endif  // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_X11_H
diff --git a/widget/gtk/WindowSurfaceX11Image.cpp b/widget/gtk/WindowSurfaceX11Image.cpp
new file mode 100644
index 0000000000..f83b64336c
--- /dev/null
+++ b/widget/gtk/WindowSurfaceX11Image.cpp
@@ -0,0 +1,254 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WindowSurfaceX11Image.h"
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Tools.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "gfxPlatform.h"
+#include "gfx2DGlue.h"
+
+#include <X11/extensions/shape.h>
+
+namespace mozilla {
+namespace widget {
+
+using namespace mozilla::gfx;
+
+// gfxImageSurface pixel format configuration.
+#define SHAPED_IMAGE_SURFACE_BPP 4
+#ifdef IS_BIG_ENDIAN
+#  define SHAPED_IMAGE_SURFACE_ALPHA_INDEX 0
+#else
+#  define SHAPED_IMAGE_SURFACE_ALPHA_INDEX 3
+#endif
+
+WindowSurfaceX11Image::WindowSurfaceX11Image(Display* aDisplay, Window aWindow,
+                                             Visual* aVisual,
+                                             unsigned int aDepth,
+                                             bool aIsShaped)
+    : WindowSurfaceX11(aDisplay, aWindow, aVisual, aDepth),
+      mTransparencyBitmap(nullptr),
+      mTransparencyBitmapWidth(0),
+      mTransparencyBitmapHeight(0),
+      mIsShaped(aIsShaped) {}
+
+WindowSurfaceX11Image::~WindowSurfaceX11Image() {
+  if (mTransparencyBitmap) {
+    delete[] mTransparencyBitmap;
+  }
+}
+
+already_AddRefed<gfx::DrawTarget> WindowSurfaceX11Image::Lock(
+    const LayoutDeviceIntRegion& aRegion) {
+  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
+  gfx::IntSize size(bounds.XMost(), bounds.YMost());
+
+  if (!mWindowSurface || mWindowSurface->CairoStatus() ||
+      !(size <= mWindowSurface->GetSize())) {
+    mWindowSurface = new gfxXlibSurface(mDisplay, mWindow, mVisual, size);
+  }
+  if (mWindowSurface->CairoStatus()) {
+    return nullptr;
+  }
+
+  if (!mImageSurface || mImageSurface->CairoStatus() ||
+      !(size <= mImageSurface->GetSize())) {
+    gfxImageFormat format = SurfaceFormatToImageFormat(mFormat);
+    if (format == gfx::SurfaceFormat::UNKNOWN) {
+      format = mDepth == 32 ? gfx::SurfaceFormat::A8R8G8B8_UINT32
+                            : gfx::SurfaceFormat::X8R8G8B8_UINT32;
+    }
+
+    // Use alpha image format for shaped window as we derive
+    // the shape bitmap from alpha channel. Must match SHAPED_IMAGE_SURFACE_BPP
+    // and SHAPED_IMAGE_SURFACE_ALPHA_INDEX.
+    if (mIsShaped) {
+      format = gfx::SurfaceFormat::A8R8G8B8_UINT32;
+    }
+
+    mImageSurface = new gfxImageSurface(size, format);
+    if (mImageSurface->CairoStatus()) {
+      return nullptr;
+    }
+  }
+
+  gfxImageFormat format = mImageSurface->Format();
+  // Cairo prefers compositing to BGRX instead of BGRA where possible.
+  // Cairo/pixman lacks some fast paths for compositing BGRX onto BGRA, so
+  // just report it as BGRX directly in that case.
+  // Otherwise, for Skia, report it as BGRA to the compositor. The alpha
+  // channel will be discarded when we put the image.
+  if (format == gfx::SurfaceFormat::X8R8G8B8_UINT32) {
+    gfx::BackendType backend = gfxVars::ContentBackend();
+    if (!gfx::Factory::DoesBackendSupportDataDrawtarget(backend)) {
+      backend = gfx::BackendType::SKIA;
+    }
+    if (backend != gfx::BackendType::CAIRO) {
+      format = gfx::SurfaceFormat::A8R8G8B8_UINT32;
+    }
+  }
+
+  return gfxPlatform::CreateDrawTargetForData(
+      mImageSurface->Data(), mImageSurface->GetSize(), mImageSurface->Stride(),
+      ImageFormatToSurfaceFormat(format));
+}
+
+// The transparency bitmap routines are derived form the ones at nsWindow.cpp.
+// The difference here is that we compose to RGBA image and then create
+// the shape mask from final image alpha channel.
+static inline int32_t GetBitmapStride(int32_t width) { return (width + 7) / 8; }
+
+static bool ChangedMaskBits(gchar* aMaskBits, int32_t aMaskWidth,
+                            int32_t aMaskHeight, const nsIntRect& aRect,
+                            uint8_t* aImageData) {
+  int32_t stride = aMaskWidth * SHAPED_IMAGE_SURFACE_BPP;
+  int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost();
+  int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth);
+  for (y = aRect.y; y < yMax; y++) {
+    gchar* maskBytes = aMaskBits + y * maskBytesPerRow;
+    uint8_t* alphas = aImageData;
+    for (x = aRect.x; x < xMax; x++) {
+      bool newBit = *(alphas + SHAPED_IMAGE_SURFACE_ALPHA_INDEX) > 0x7f;
+      alphas += SHAPED_IMAGE_SURFACE_BPP;
+
+      gchar maskByte = maskBytes[x >> 3];
+      bool maskBit = (maskByte & (1 << (x & 7))) != 0;
+
+      if (maskBit != newBit) {
+        return true;
+      }
+    }
+    aImageData += stride;
+  }
+
+  return false;
+}
+
+static void UpdateMaskBits(gchar* aMaskBits, int32_t aMaskWidth,
+                           int32_t aMaskHeight, const nsIntRect& aRect,
+                           uint8_t* aImageData) {
+  int32_t stride = aMaskWidth * SHAPED_IMAGE_SURFACE_BPP;
+  int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost();
+  int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth);
+  for (y = aRect.y; y < yMax; y++) {
+    gchar* maskBytes = aMaskBits + y * maskBytesPerRow;
+    uint8_t* alphas = aImageData;
+    for (x = aRect.x; x < xMax; x++) {
+      bool newBit = *(alphas + SHAPED_IMAGE_SURFACE_ALPHA_INDEX) > 0x7f;
+      alphas += SHAPED_IMAGE_SURFACE_BPP;
+
+      gchar mask = 1 << (x & 7);
+      gchar maskByte = maskBytes[x >> 3];
+      // Note: '-newBit' turns 0 into 00...00 and 1 into 11...11
+      maskBytes[x >> 3] = (maskByte & ~mask) | (-newBit & mask);
+    }
+    aImageData += stride;
+  }
+}
+
+void WindowSurfaceX11Image::ResizeTransparencyBitmap(int aWidth, int aHeight) {
+  int32_t actualSize =
+      GetBitmapStride(mTransparencyBitmapWidth) * mTransparencyBitmapHeight;
+  int32_t newSize = GetBitmapStride(aWidth) * aHeight;
+
+  if (actualSize < newSize) {
+    delete[] mTransparencyBitmap;
+    mTransparencyBitmap = new gchar[newSize];
+  }
+
+  mTransparencyBitmapWidth = aWidth;
+  mTransparencyBitmapHeight = aHeight;
+}
+
+void WindowSurfaceX11Image::ApplyTransparencyBitmap() {
+  gfx::IntSize size = mWindowSurface->GetSize();
+  bool maskChanged = true;
+
+  if (!mTransparencyBitmap) {
+    mTransparencyBitmapWidth = size.width;
+    mTransparencyBitmapHeight = size.height;
+
+    int32_t byteSize =
+        GetBitmapStride(mTransparencyBitmapWidth) * mTransparencyBitmapHeight;
+    mTransparencyBitmap = new gchar[byteSize];
+  } else {
+    bool sizeChanged = (size.width != mTransparencyBitmapWidth ||
+                        size.height != mTransparencyBitmapHeight);
+
+    if (sizeChanged) {
+      ResizeTransparencyBitmap(size.width, size.height);
+    } else {
+      maskChanged = ChangedMaskBits(
+          mTransparencyBitmap, mTransparencyBitmapWidth,
+          mTransparencyBitmapHeight, nsIntRect(0, 0, size.width, size.height),
+          (uint8_t*)mImageSurface->Data());
+    }
+  }
+
+  if (maskChanged) {
+    UpdateMaskBits(mTransparencyBitmap, mTransparencyBitmapWidth,
+                   mTransparencyBitmapHeight,
+                   nsIntRect(0, 0, size.width, size.height),
+                   (uint8_t*)mImageSurface->Data());
+
+    // We use X11 calls where possible, because GDK handles expose events
+    // for shaped windows in a way that's incompatible with us (Bug 635903).
+    // It doesn't occur when the shapes are set through X.
+    Display* xDisplay = mWindowSurface->XDisplay();
+    Window xDrawable = mWindowSurface->XDrawable();
+    Pixmap maskPixmap = XCreateBitmapFromData(
+        xDisplay, xDrawable, mTransparencyBitmap, mTransparencyBitmapWidth,
+        mTransparencyBitmapHeight);
+    XShapeCombineMask(xDisplay, xDrawable, ShapeBounding, 0, 0, maskPixmap,
+                      ShapeSet);
+    XFreePixmap(xDisplay, maskPixmap);
+  }
+}
+
+void WindowSurfaceX11Image::Commit(
+    const LayoutDeviceIntRegion& aInvalidRegion) {
+  RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateDrawTargetForCairoSurface(
+      mWindowSurface->CairoSurface(), mWindowSurface->GetSize());
+  RefPtr<gfx::SourceSurface> surf =
+      gfx::Factory::CreateSourceSurfaceForCairoSurface(
+          mImageSurface->CairoSurface(), mImageSurface->GetSize(),
+          mImageSurface->Format());
+  if (!dt || !surf) {
+    return;
+  }
+
+  gfx::IntRect bounds = aInvalidRegion.GetBounds().ToUnknownRect();
+  if (bounds.IsEmpty()) {
+    return;
+  }
+
+  if (mIsShaped) {
+    ApplyTransparencyBitmap();
+  }
+
+  uint32_t numRects = aInvalidRegion.GetNumRects();
+  if (numRects == 1) {
+    dt->CopySurface(surf, bounds, bounds.TopLeft());
+  } else {
+    AutoTArray<IntRect, 32> rects;
+    rects.SetCapacity(numRects);
+    for (auto iter = aInvalidRegion.RectIter(); !iter.Done(); iter.Next()) {
+      rects.AppendElement(iter.Get().ToUnknownRect());
+    }
+    dt->PushDeviceSpaceClipRects(rects.Elements(), rects.Length());
+
+    dt->DrawSurface(surf, gfx::Rect(bounds), gfx::Rect(bounds),
+                    DrawSurfaceOptions(),
+                    DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+
+    dt->PopClip();
+  }
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/WindowSurfaceX11Image.h b/widget/gtk/WindowSurfaceX11Image.h
new file mode 100644
index 0000000000..b8b2a33f0e
--- /dev/null
+++ b/widget/gtk/WindowSurfaceX11Image.h
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_X11_IMAGE_H
+#define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_X11_IMAGE_H
+
+#ifdef MOZ_X11
+
+#  include <glib.h>
+#  include "WindowSurfaceX11.h"
+#  include "gfxXlibSurface.h"
+#  include "gfxImageSurface.h"
+
+namespace mozilla {
+namespace widget {
+
+class WindowSurfaceX11Image : public WindowSurfaceX11 {
+ public:
+  WindowSurfaceX11Image(Display* aDisplay, Window aWindow, Visual* aVisual,
+                        unsigned int aDepth, bool aIsShaped);
+  ~WindowSurfaceX11Image();
+
+  already_AddRefed<gfx::DrawTarget> Lock(
+      const LayoutDeviceIntRegion& aRegion) override;
+  void Commit(const LayoutDeviceIntRegion& aInvalidRegion) override;
+  bool IsFallback() const override { return true; }
+
+ private:
+  void ResizeTransparencyBitmap(int aWidth, int aHeight);
+  void ApplyTransparencyBitmap();
+
+  RefPtr<gfxXlibSurface> mWindowSurface;
+  RefPtr<gfxImageSurface> mImageSurface;
+
+  gchar* mTransparencyBitmap;
+  int32_t mTransparencyBitmapWidth;
+  int32_t mTransparencyBitmapHeight;
+  bool mIsShaped;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // MOZ_X11
+#endif  // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_X11_IMAGE_H
diff --git a/widget/gtk/WindowSurfaceX11SHM.cpp b/widget/gtk/WindowSurfaceX11SHM.cpp
new file mode 100644
index 0000000000..889881d22d
--- /dev/null
+++ b/widget/gtk/WindowSurfaceX11SHM.cpp
@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WindowSurfaceX11SHM.h"
+
+namespace mozilla::widget {
+
+WindowSurfaceX11SHM::WindowSurfaceX11SHM(Display* aDisplay, Drawable aWindow,
+                                         Visual* aVisual, unsigned int aDepth) {
+  mFrontImage = new nsShmImage(aDisplay, aWindow, aVisual, aDepth);
+  mBackImage = new nsShmImage(aDisplay, aWindow, aVisual, aDepth);
+}
+
+already_AddRefed<gfx::DrawTarget> WindowSurfaceX11SHM::Lock(
+    const LayoutDeviceIntRegion& aRegion) {
+  mBackImage.swap(mFrontImage);
+  return mBackImage->CreateDrawTarget(aRegion);
+}
+
+void WindowSurfaceX11SHM::Commit(const LayoutDeviceIntRegion& aInvalidRegion) {
+  mBackImage->Put(aInvalidRegion);
+}
+
+}  // namespace mozilla::widget
diff --git a/widget/gtk/WindowSurfaceX11SHM.h b/widget/gtk/WindowSurfaceX11SHM.h
new file mode 100644
index 0000000000..5d12137f7b
--- /dev/null
+++ b/widget/gtk/WindowSurfaceX11SHM.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MOZILLA_WIDGET_WINDOW_SURFACE_X11_SHM_H
+#define _MOZILLA_WIDGET_WINDOW_SURFACE_X11_SHM_H
+
+#ifdef MOZ_X11
+
+#  include "mozilla/widget/WindowSurface.h"
+#  include "nsShmImage.h"
+
+namespace mozilla {
+namespace widget {
+
+class WindowSurfaceX11SHM : public WindowSurface {
+ public:
+  WindowSurfaceX11SHM(Display* aDisplay, Drawable aWindow, Visual* aVisual,
+                      unsigned int aDepth);
+
+  already_AddRefed<gfx::DrawTarget> Lock(
+      const LayoutDeviceIntRegion& aRegion) override;
+  void Commit(const LayoutDeviceIntRegion& aInvalidRegion) override;
+
+ private:
+  RefPtr<nsShmImage> mFrontImage;
+  RefPtr<nsShmImage> mBackImage;
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif  // MOZ_X11
+#endif  // _MOZILLA_WIDGET_WINDOW_SURFACE_X11_SHM_H
diff --git a/widget/gtk/compat/gdk/gdkdnd.h b/widget/gtk/compat/gdk/gdkdnd.h
new file mode 100644
index 0000000000..bf9888d84f
--- /dev/null
+++ b/widget/gtk/compat/gdk/gdkdnd.h
@@ -0,0 +1,29 @@
+/* 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 GDKDND_WRAPPER_H
+#define GDKDND_WRAPPER_H
+
+#define gdk_drag_context_get_actions gdk_drag_context_get_actions_
+#define gdk_drag_context_list_targets gdk_drag_context_list_targets_
+#define gdk_drag_context_get_dest_window gdk_drag_context_get_dest_window_
+#include_next <gdk/gdkdnd.h>
+#undef gdk_drag_context_get_actions
+#undef gdk_drag_context_list_targets
+#undef gdk_drag_context_get_dest_window
+
+static inline GdkDragAction gdk_drag_context_get_actions(
+    GdkDragContext* context) {
+  return context->actions;
+}
+
+static inline GList* gdk_drag_context_list_targets(GdkDragContext* context) {
+  return context->targets;
+}
+
+static inline GdkWindow* gdk_drag_context_get_dest_window(
+    GdkDragContext* context) {
+  return context->dest_window;
+}
+#endif /* GDKDND_WRAPPER_H */
diff --git a/widget/gtk/compat/gdk/gdkkeysyms.h b/widget/gtk/compat/gdk/gdkkeysyms.h
new file mode 100644
index 0000000000..2f48d61fcc
--- /dev/null
+++ b/widget/gtk/compat/gdk/gdkkeysyms.h
@@ -0,0 +1,266 @@
+/* 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 GDKKEYSYMS_WRAPPER_H
+#define GDKKEYSYMS_WRAPPER_H
+
+#include_next <gdk/gdkkeysyms.h>
+
+#ifndef GDK_ISO_Level5_Shift
+#  define GDK_ISO_Level5_Shift 0xFE11
+#endif
+
+#ifndef GDK_ISO_Level5_Latch
+#  define GDK_ISO_Level5_Latch 0xFE12
+#endif
+
+#ifndef GDK_ISO_Level5_Lock
+#  define GDK_ISO_Level5_Lock 0xFE13
+#endif
+
+#ifndef GDK_dead_greek
+#  define GDK_dead_greek 0xFE8C
+#endif
+
+#ifndef GDK_ch
+#  define GDK_ch 0xFEA0
+#endif
+
+#ifndef GDK_Ch
+#  define GDK_Ch 0xFEA1
+#endif
+
+#ifndef GDK_CH
+#  define GDK_CH 0xFEA2
+#endif
+
+#ifndef GDK_c_h
+#  define GDK_c_h 0xFEA3
+#endif
+
+#ifndef GDK_C_h
+#  define GDK_C_h 0xFEA4
+#endif
+
+#ifndef GDK_C_H
+#  define GDK_C_H 0xFEA5
+#endif
+
+#ifndef GDK_MonBrightnessUp
+#  define GDK_MonBrightnessUp 0x1008FF02
+#endif
+
+#ifndef GDK_MonBrightnessDown
+#  define GDK_MonBrightnessDown 0x1008FF03
+#endif
+
+#ifndef GDK_AudioLowerVolume
+#  define GDK_AudioLowerVolume 0x1008FF11
+#endif
+
+#ifndef GDK_AudioMute
+#  define GDK_AudioMute 0x1008FF12
+#endif
+
+#ifndef GDK_AudioRaiseVolume
+#  define GDK_AudioRaiseVolume 0x1008FF13
+#endif
+
+#ifndef GDK_AudioPlay
+#  define GDK_AudioPlay 0x1008FF14
+#endif
+
+#ifndef GDK_AudioStop
+#  define GDK_AudioStop 0x1008FF15
+#endif
+
+#ifndef GDK_AudioPrev
+#  define GDK_AudioPrev 0x1008FF16
+#endif
+
+#ifndef GDK_AudioNext
+#  define GDK_AudioNext 0x1008FF17
+#endif
+
+#ifndef GDK_HomePage
+#  define GDK_HomePage 0x1008FF18
+#endif
+
+#ifndef GDK_Mail
+#  define GDK_Mail 0x1008FF19
+#endif
+
+#ifndef GDK_Search
+#  define GDK_Search 0x1008FF1B
+#endif
+
+#ifndef GDK_AudioRecord
+#  define GDK_AudioRecord 0x1008FF1C
+#endif
+
+#ifndef GDK_Back
+#  define GDK_Back 0x1008FF26
+#endif
+
+#ifndef GDK_Forward
+#  define GDK_Forward 0x1008FF27
+#endif
+
+#ifndef GDK_Stop
+#  define GDK_Stop 0x1008FF28
+#endif
+
+#ifndef GDK_Refresh
+#  define GDK_Refresh 0x1008FF29
+#endif
+
+#ifndef GDK_PowerOff
+#  define GDK_PowerOff 0x1008FF2A
+#endif
+
+#ifndef GDK_Eject
+#  define GDK_Eject 0x1008FF2C
+#endif
+
+#ifndef GDK_AudioPause
+#  define GDK_AudioPause 0x1008FF31
+#endif
+
+#ifndef GDK_BrightnessAdjust
+#  define GDK_BrightnessAdjust 0x1008FF3B
+#endif
+
+#ifndef GDK_AudioRewind
+#  define GDK_AudioRewind 0x1008FF3E
+#endif
+
+#ifndef GDK_Launch0
+#  define GDK_Launch0 0x1008FF40
+#endif
+
+#ifndef GDK_Launch1
+#  define GDK_Launch1 0x1008FF41
+#endif
+
+#ifndef GDK_Launch2
+#  define GDK_Launch2 0x1008FF42
+#endif
+
+#ifndef GDK_Launch3
+#  define GDK_Launch3 0x1008FF43
+#endif
+
+#ifndef GDK_Launch4
+#  define GDK_Launch4 0x1008FF44
+#endif
+
+#ifndef GDK_Launch5
+#  define GDK_Launch5 0x1008FF45
+#endif
+
+#ifndef GDK_Launch6
+#  define GDK_Launch6 0x1008FF46
+#endif
+
+#ifndef GDK_Launch7
+#  define GDK_Launch7 0x1008FF47
+#endif
+
+#ifndef GDK_Launch8
+#  define GDK_Launch8 0x1008FF48
+#endif
+
+#ifndef GDK_Launch9
+#  define GDK_Launch9 0x1008FF49
+#endif
+
+#ifndef GDK_LaunchA
+#  define GDK_LaunchA 0x1008FF4A
+#endif
+
+#ifndef GDK_LaunchB
+#  define GDK_LaunchB 0x1008FF4B
+#endif
+
+#ifndef GDK_LaunchC
+#  define GDK_LaunchC 0x1008FF4C
+#endif
+
+#ifndef GDK_LaunchD
+#  define GDK_LaunchD 0x1008FF4D
+#endif
+
+#ifndef GDK_LaunchE
+#  define GDK_LaunchE 0x1008FF4E
+#endif
+
+#ifndef GDK_LaunchF
+#  define GDK_LaunchF 0x1008FF4F
+#endif
+
+#ifndef GDK_Copy
+#  define GDK_Copy 0x1008FF57
+#endif
+
+#ifndef GDK_Cut
+#  define GDK_Cut 0x1008FF58
+#endif
+
+#ifndef GDK_Paste
+#  define GDK_Paste 0x1008FF6D
+#endif
+
+#ifndef GDK_Reload
+#  define GDK_Reload 0x1008FF73
+#endif
+
+#ifndef GDK_AudioRandomPlay
+#  define GDK_AudioRandomPlay 0x1008FF99
+#endif
+
+#ifndef GDK_Subtitle
+#  define GDK_Subtitle 0x1008FF9A
+#endif
+
+#ifndef GDK_Red
+#  define GDK_Red 0x1008FFA3
+#endif
+
+#ifndef GDK_Green
+#  define GDK_Green 0x1008FFA4
+#endif
+
+#ifndef GDK_Yellow
+#  define GDK_Yellow 0x1008FFA5
+#endif
+
+#ifndef GDK_Blue
+#  define GDK_Blue 0x1008FFA6
+#endif
+
+#ifndef GDK_TouchpadToggle
+#  define GDK_TouchpadToggle 0x1008FFA9
+#endif
+
+#ifndef GDK_TouchpadOn
+#  define GDK_TouchpadOn 0x1008FFB0
+#endif
+
+#ifndef GDK_TouchpadOff
+#  define GDK_TouchpadOff 0x1008ffb1
+#endif
+
+#ifndef GDK_LogWindowTree
+#  define GDK_LogWindowTree 0x1008FE24
+#endif
+
+#ifndef GDK_LogGrabInfo
+#  define GDK_LogGrabInfo 0x1008FE25
+#endif
+
+#ifndef GDK_Sleep
+#  define GDK_Sleep 0x1008FF2F
+#endif
+
+#endif /* GDKKEYSYMS_WRAPPER_H */
diff --git a/widget/gtk/compat/gdk/gdkvisual.h b/widget/gtk/compat/gdk/gdkvisual.h
new file mode 100644
index 0000000000..e5187a78da
--- /dev/null
+++ b/widget/gtk/compat/gdk/gdkvisual.h
@@ -0,0 +1,15 @@
+/* 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 GDKVISUAL_WRAPPER_H
+#define GDKVISUAL_WRAPPER_H
+
+#define gdk_visual_get_depth gdk_visual_get_depth_
+#include_next <gdk/gdkvisual.h>
+#undef gdk_visual_get_depth
+
+static inline gint gdk_visual_get_depth(GdkVisual* visual) {
+  return visual->depth;
+}
+#endif /* GDKVISUAL_WRAPPER_H */
diff --git a/widget/gtk/compat/gdk/gdkwindow.h b/widget/gtk/compat/gdk/gdkwindow.h
new file mode 100644
index 0000000000..a4d2efbc89
--- /dev/null
+++ b/widget/gtk/compat/gdk/gdkwindow.h
@@ -0,0 +1,27 @@
+/* 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 GDKWINDOW_WRAPPER_H
+#define GDKWINDOW_WRAPPER_H
+
+#define gdk_window_get_display gdk_window_get_display_
+#define gdk_window_get_screen gdk_window_get_screen_
+#include_next <gdk/gdkwindow.h>
+#undef gdk_window_get_display
+#undef gdk_window_get_screen
+
+static inline GdkDisplay* gdk_window_get_display(GdkWindow* window) {
+  return gdk_drawable_get_display(GDK_DRAWABLE(window));
+}
+
+static inline GdkScreen* gdk_window_get_screen(GdkWindow* window) {
+  return gdk_drawable_get_screen(window);
+}
+
+#if GDK_PIXBUF_MAJOR == 2 && GDK_PIXBUF_MINOR < 18
+static inline gboolean gdk_window_is_destroyed(GdkWindow* window) {
+  return GDK_WINDOW_OBJECT(window)->destroyed;
+}
+#endif
+#endif /* GDKWINDOW_WRAPPER_H */
diff --git a/widget/gtk/compat/gdk/gdkx.h b/widget/gtk/compat/gdk/gdkx.h
new file mode 100644
index 0000000000..7b0718f3cb
--- /dev/null
+++ b/widget/gtk/compat/gdk/gdkx.h
@@ -0,0 +1,42 @@
+/* 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 GDKX_WRAPPER_H
+#define GDKX_WRAPPER_H
+
+#include <gtk/gtkversion.h>
+
+#define gdk_x11_window_foreign_new_for_display \
+  gdk_x11_window_foreign_new_for_display_
+#define gdk_x11_window_lookup_for_display gdk_x11_window_lookup_for_display_
+#define gdk_x11_window_get_xid gdk_x11_window_get_xid_
+#if !GTK_CHECK_VERSION(2, 24, 0)
+#  define gdk_x11_set_sm_client_id gdk_x11_set_sm_client_id_
+#endif
+#include_next <gdk/gdkx.h>
+#undef gdk_x11_window_foreign_new_for_display
+#undef gdk_x11_window_lookup_for_display
+#undef gdk_x11_window_get_xid
+
+static inline GdkWindow* gdk_x11_window_foreign_new_for_display(
+    GdkDisplay* display, Window window) {
+  return gdk_window_foreign_new_for_display(display, window);
+}
+
+static inline GdkWindow* gdk_x11_window_lookup_for_display(GdkDisplay* display,
+                                                           Window window) {
+  return gdk_window_lookup_for_display(display, window);
+}
+
+static inline Window gdk_x11_window_get_xid(GdkWindow* window) {
+  return (GDK_WINDOW_XWINDOW(window));
+}
+
+#if !GTK_CHECK_VERSION(2, 24, 0)
+#  undef gdk_x11_set_sm_client_id
+static inline void gdk_x11_set_sm_client_id(const gchar* sm_client_id) {
+  gdk_set_sm_client_id(sm_client_id);
+}
+#endif
+#endif /* GDKX_WRAPPER_H */
diff --git a/widget/gtk/compat/glib/gmem.h b/widget/gtk/compat/glib/gmem.h
new file mode 100644
index 0000000000..78f24bbd8d
--- /dev/null
+++ b/widget/gtk/compat/glib/gmem.h
@@ -0,0 +1,48 @@
+/* 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 GMEM_WRAPPER_H
+#define GMEM_WRAPPER_H
+
+#define g_malloc_n g_malloc_n_
+#define g_malloc0_n g_malloc0_n_
+#define g_realloc_n g_realloc_n_
+#include_next <glib/gmem.h>
+#undef g_malloc_n
+#undef g_malloc0_n
+#undef g_realloc_n
+
+#include <glib/gmessages.h>
+
+#undef g_new
+#define g_new(type, num) ((type*)g_malloc_n((num), sizeof(type)))
+
+#undef g_new0
+#define g_new0(type, num) ((type*)g_malloc0_n((num), sizeof(type)))
+
+#undef g_renew
+#define g_renew(type, ptr, num) ((type*)g_realloc_n(ptr, (num), sizeof(type)))
+
+#define _CHECK_OVERFLOW(num, type_size)                                    \
+  if (G_UNLIKELY(type_size > 0 && num > G_MAXSIZE / type_size)) {          \
+    g_error("%s: overflow allocating %" G_GSIZE_FORMAT "*%" G_GSIZE_FORMAT \
+            " bytes",                                                      \
+            G_STRLOC, num, type_size);                                     \
+  }
+
+static inline gpointer g_malloc_n(gsize num, gsize type_size) {
+  _CHECK_OVERFLOW(num, type_size)
+  return g_malloc(num * type_size);
+}
+
+static inline gpointer g_malloc0_n(gsize num, gsize type_size) {
+  _CHECK_OVERFLOW(num, type_size)
+  return g_malloc0(num * type_size);
+}
+
+static inline gpointer g_realloc_n(gpointer ptr, gsize num, gsize type_size) {
+  _CHECK_OVERFLOW(num, type_size)
+  return g_realloc(ptr, num * type_size);
+}
+#endif /* GMEM_WRAPPER_H */
diff --git a/widget/gtk/compat/gtk/gtkwidget.h b/widget/gtk/compat/gtk/gtkwidget.h
new file mode 100644
index 0000000000..21165d61fa
--- /dev/null
+++ b/widget/gtk/compat/gtk/gtkwidget.h
@@ -0,0 +1,43 @@
+/* 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 GTKWIDGET_WRAPPER_H
+#define GTKWIDGET_WRAPPER_H
+
+#define gtk_widget_set_mapped gtk_widget_set_mapped_
+#define gtk_widget_get_mapped gtk_widget_get_mapped_
+#define gtk_widget_set_realized gtk_widget_set_realized_
+#define gtk_widget_get_realized gtk_widget_get_realized_
+#include_next <gtk/gtkwidget.h>
+#undef gtk_widget_set_mapped
+#undef gtk_widget_get_mapped
+#undef gtk_widget_set_realized
+#undef gtk_widget_get_realized
+
+#include <gtk/gtkversion.h>
+
+static inline void gtk_widget_set_mapped(GtkWidget* widget, gboolean mapped) {
+  if (mapped)
+    GTK_WIDGET_SET_FLAGS(widget, GTK_MAPPED);
+  else
+    GTK_WIDGET_UNSET_FLAGS(widget, GTK_MAPPED);
+}
+
+static inline gboolean gtk_widget_get_mapped(GtkWidget* widget) {
+  return GTK_WIDGET_MAPPED(widget);
+}
+
+static inline void gtk_widget_set_realized(GtkWidget* widget,
+                                           gboolean realized) {
+  if (realized)
+    GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+  else
+    GTK_WIDGET_UNSET_FLAGS(widget, GTK_REALIZED);
+}
+
+static inline gboolean gtk_widget_get_realized(GtkWidget* widget) {
+  return GTK_WIDGET_REALIZED(widget);
+}
+
+#endif /* GTKWIDGET_WRAPPER_H */
diff --git a/widget/gtk/compat/gtk/gtkwindow.h b/widget/gtk/compat/gtk/gtkwindow.h
new file mode 100644
index 0000000000..7c3d5873bd
--- /dev/null
+++ b/widget/gtk/compat/gtk/gtkwindow.h
@@ -0,0 +1,26 @@
+/* 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 GTKWINDOW_WRAPPER_H
+#define GTKWINDOW_WRAPPER_H
+
+#define gtk_window_group_get_current_grab gtk_window_group_get_current_grab_
+#define gtk_window_get_window_type gtk_window_get_window_type_
+#include_next <gtk/gtkwindow.h>
+#undef gtk_window_group_get_current_grab
+#undef gtk_window_get_window_type
+
+static inline GtkWidget* gtk_window_group_get_current_grab(
+    GtkWindowGroup* window_group) {
+  if (!window_group->grabs) return NULL;
+
+  return GTK_WIDGET(window_group->grabs->data);
+}
+
+static inline GtkWindowType gtk_window_get_window_type(GtkWindow* window) {
+  gint type;
+  g_object_get(window, "type", &type, (void*)NULL);
+  return (GtkWindowType)type;
+}
+#endif /* GTKWINDOW_WRAPPER_H */
diff --git a/widget/gtk/components.conf b/widget/gtk/components.conf
new file mode 100644
index 0000000000..a2759a3c45
--- /dev/null
+++ b/widget/gtk/components.conf
@@ -0,0 +1,151 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+Headers = [
+    '/widget/gtk/nsWidgetFactory.h',
+]
+
+InitFunc = 'nsWidgetGtk2ModuleCtor'
+UnloadFunc = 'nsWidgetGtk2ModuleDtor'
+
+Classes = [
+    {
+        'cid': '{2d96b3df-c051-11d1-a827-0040959a28c9}',
+        'contract_ids': ['@mozilla.org/widget/appshell/gtk;1'],
+        'legacy_constructor': 'nsAppShellConstructor',
+        'headers': ['/widget/gtk/nsWidgetFactory.h'],
+        'processes': ProcessSelector.ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS,
+    },
+    {
+        'cid': '{e9537f8f-c07e-4435-8ab3-83f1ad6e3bbf}',
+        'contract_ids': ['@mozilla.org/gfx/parent/screenmanager;1'],
+        'singleton': True,
+        'type': 'mozilla::widget::ScreenManager',
+        'headers': ['mozilla/StaticPtr.h', 'mozilla/widget/ScreenManager.h'],
+        'constructor': 'mozilla::widget::ScreenManager::GetAddRefedSingleton',
+        'processes': ProcessSelector.ALLOW_IN_GPU_AND_MAIN_PROCESS,
+    },
+    {
+        'cid': '{a9339876-0027-430f-b953-84c9c11c2da3}',
+        'contract_ids': ['@mozilla.org/widget/taskbarprogress/gtk;1'],
+        'type': 'TaskbarProgress',
+        'headers': ['/widget/gtk/TaskbarProgress.h'],
+    },
+    {
+        'cid': '{4364de1a-798e-419c-a6f5-ca28866b6d5f}',
+        'contract_ids': ['@mozilla.org/parent/colorpicker;1'],
+        'type': 'nsColorPicker',
+        'headers': ['/widget/gtk/nsColorPicker.h'],
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+    {
+        'cid': '{1940fed5-7d02-4122-8acf-7abaac698983}',
+        'contract_ids': ['@mozilla.org/parent/filepicker;1'],
+        'type': 'nsFilePicker',
+        'headers': ['/widget/gtk/nsFilePicker.h'],
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+    {
+        'cid': '{948a0023-e3a7-11d2-96cf-0060b0fb9956}',
+        'contract_ids': ['@mozilla.org/widget/htmlformatconverter;1'],
+        'type': 'nsHTMLFormatConverter',
+        'headers': ['/widget/nsHTMLFormatConverter.h'],
+    },
+    {
+        'cid': '{e711c28b-c1f1-4b87-8448-e1e0da0a7b7d}',
+        'contract_ids': ['@mozilla.org/parent/sound;1'],
+        'singleton': True,
+        'type': 'nsISound',
+        'constructor': 'nsSound::GetInstance',
+        'headers': ['/widget/gtk/nsSound.h'],
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+    {
+        'cid': '{8b5314bc-db01-11d2-96ce-0060b0fb9956}',
+        'contract_ids': ['@mozilla.org/widget/transferable;1'],
+        'type': 'nsTransferable',
+        'headers': ['/widget/nsTransferable.h'],
+    },
+    {
+        'cid': '{e221df9b-3d66-4045-9a66-5720949f8d10}',
+        'contract_ids': ['@mozilla.org/applicationchooser;1'],
+        'type': 'nsApplicationChooser',
+        'headers': ['/widget/gtk/nsApplicationChooser.h'],
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+    {
+        'cid': '{f55f5d31-dbb7-4d0d-9f6f-a4f4cd8e8ef1}',
+        'contract_ids': ['@mozilla.org/widget/parent/clipboard;1'],
+        'interfaces': ['nsIClipboard'],
+        'type': 'nsIClipboard',
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+    {
+        'cid': '{77221d5a-1dd2-11b2-8c69-c710f15d2ed5}',
+        'contract_ids': ['@mozilla.org/widget/clipboardhelper;1'],
+        'type': 'nsClipboardHelper',
+        'headers': ['/widget/nsClipboardHelper.h'],
+    },
+    {
+        'cid': '{0ba77e04-2adb-422f-af01-5a57b8013100}',
+        'contract_ids': ['@mozilla.org/widget/parent/dragservice;1'],
+        'singleton': True,
+        'type': 'nsDragService',
+        'headers': ['/widget/gtk/nsDragService.h'],
+        'constructor': 'nsDragService::GetInstance',
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+    {
+        'name': 'GfxInfo',
+        'cid': '{d755a760-9f27-11df-0800-200c9a664242}',
+        'contract_ids': ['@mozilla.org/gfx/info;1'],
+        'type': 'mozilla::widget::GfxInfo',
+        'headers': ['/widget/gtk/GfxInfo.h'],
+        'init_method': 'Init',
+        'processes': ProcessSelector.ALLOW_IN_GPU_PROCESS,
+    },
+    {
+        'cid': '{6987230e-0098-4e78-bc5f-1493ee7519fa}',
+        'contract_ids': ['@mozilla.org/widget/useridleservice;1'],
+        'singleton': True,
+        'type': 'nsUserIdleService',
+        'headers': ['/widget/gtk/nsUserIdleServiceGTK.h'],
+        'constructor': 'nsUserIdleServiceGTK::GetInstance',
+    },
+]
+
+if defined('NS_PRINTING'):
+    Classes += [
+        {
+            'cid': '{d3f69889-e13a-4321-980c-a39332e21f34}',
+            'contract_ids': ['@mozilla.org/gfx/devicecontextspec;1'],
+            'type': 'nsDeviceContextSpecGTK',
+            'headers': ['/widget/gtk/nsDeviceContextSpecG.h'],
+            'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+        },
+        {
+            'cid': '{06beec76-a183-4d9f-85dd-085f26da565a}',
+            'contract_ids': ['@mozilla.org/widget/printdialog-service;1'],
+            'type': 'nsPrintDialogServiceGTK',
+            'headers': ['/widget/gtk/nsPrintDialogGTK.h'],
+            'init_method': 'Init',
+            'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+        },
+        {
+            'cid': '{841387c8-72e6-484b-9296-bf6eea80d58a}',
+            'contract_ids': ['@mozilla.org/gfx/printsettings-service;1'],
+            'type': 'nsPrintSettingsServiceGTK',
+            'headers': ['/widget/gtk/nsPrintSettingsServiceGTK.h'],
+            'init_method': 'Init',
+        },
+        {
+            'cid': '{a6cf9129-15b3-11d2-932e-00805f8add32}',
+            'contract_ids': ['@mozilla.org/gfx/printerlist;1'],
+            'type': 'nsPrinterListCUPS',
+            'headers': ['/widget/nsPrinterListCUPS.h'],
+            'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+        },
+    ]
diff --git a/widget/gtk/crashtests/540078-1.xhtml b/widget/gtk/crashtests/540078-1.xhtml
new file mode 100644
index 0000000000..f5de1b9aee
--- /dev/null
+++ b/widget/gtk/crashtests/540078-1.xhtml
@@ -0,0 +1 @@
+<html xmlns="http://www.w3.org/1999/xhtml"><hbox xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"><scrollcorner class="zebra"/></hbox><style style="display: none;">.zebra { -moz-appearance: checkbox; }</style></html>
diff --git a/widget/gtk/crashtests/673390-1.html b/widget/gtk/crashtests/673390-1.html
new file mode 100644
index 0000000000..8463f67f05
--- /dev/null
+++ b/widget/gtk/crashtests/673390-1.html
@@ -0,0 +1 @@
+<div style="-moz-appearance: progresschunk; position: fixed"></div>
diff --git a/widget/gtk/crashtests/crashtests.list b/widget/gtk/crashtests/crashtests.list
new file mode 100644
index 0000000000..9ae47c2233
--- /dev/null
+++ b/widget/gtk/crashtests/crashtests.list
@@ -0,0 +1,2 @@
+load 540078-1.xhtml
+load 673390-1.html
diff --git a/widget/gtk/gtk3drawing.cpp b/widget/gtk/gtk3drawing.cpp
new file mode 100644
index 0000000000..afa4f5f489
--- /dev/null
+++ b/widget/gtk/gtk3drawing.cpp
@@ -0,0 +1,2738 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This file contains painting functions for each of the gtk2 widgets.
+ * Adapted from the gtkdrawing.c, and gtk+2.0 source.
+ */
+
+#include <gtk/gtk.h>
+#include <gdk/gdkprivate.h>
+#include <string.h>
+#include "gtkdrawing.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/ScopeExit.h"
+#include "prinrval.h"
+#include "WidgetStyleCache.h"
+#include "nsString.h"
+#include "nsDebug.h"
+#include "WidgetUtilsGtk.h"
+
+#include <math.h>
+#include <dlfcn.h>
+
+static gboolean checkbox_check_state;
+static gboolean notebook_has_tab_gap;
+
+static ToggleGTKMetrics sCheckboxMetrics;
+static ToggleGTKMetrics sRadioMetrics;
+static ToggleGTKMetrics sMenuRadioMetrics;
+static ToggleGTKMetrics sMenuCheckboxMetrics;
+static ToolbarGTKMetrics sToolbarMetrics;
+static CSDWindowDecorationSize sToplevelWindowDecorationSize;
+static CSDWindowDecorationSize sPopupWindowDecorationSize;
+
+using mozilla::Span;
+
+#define ARROW_UP 0
+#define ARROW_DOWN G_PI
+#define ARROW_RIGHT G_PI_2
+#define ARROW_LEFT (G_PI + G_PI_2)
+
+#if 0
+// It's used for debugging only to compare Gecko widget style with
+// the ones used by Gtk+ applications.
+static void
+style_path_print(GtkStyleContext *context)
+{
+    const GtkWidgetPath* path = gtk_style_context_get_path(context);
+
+    static auto sGtkWidgetPathToStringPtr =
+        (char * (*)(const GtkWidgetPath *))
+        dlsym(RTLD_DEFAULT, "gtk_widget_path_to_string");
+
+    fprintf(stderr, "Style path:\n%s\n\n", sGtkWidgetPathToStringPtr(path));
+}
+#endif
+
+static GtkBorder operator+=(GtkBorder& first, const GtkBorder& second) {
+  first.left += second.left;
+  first.right += second.right;
+  first.top += second.top;
+  first.bottom += second.bottom;
+  return first;
+}
+
+static gint moz_gtk_get_tab_thickness(GtkStyleContext* style);
+
+static gint moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t* cr,
+                                    GdkRectangle* rect, GtkWidgetState* state,
+                                    GtkTextDirection direction);
+
+static void Inset(GdkRectangle*, const GtkBorder&);
+
+static void InsetByMargin(GdkRectangle*, GtkStyleContext* style);
+
+static void moz_gtk_add_style_margin(GtkStyleContext* style, gint* left,
+                                     gint* top, gint* right, gint* bottom) {
+  GtkBorder margin;
+
+  gtk_style_context_get_margin(style, gtk_style_context_get_state(style),
+                               &margin);
+  *left += margin.left;
+  *right += margin.right;
+  *top += margin.top;
+  *bottom += margin.bottom;
+}
+
+static void moz_gtk_add_style_border(GtkStyleContext* style, gint* left,
+                                     gint* top, gint* right, gint* bottom) {
+  GtkBorder border;
+
+  gtk_style_context_get_border(style, gtk_style_context_get_state(style),
+                               &border);
+
+  *left += border.left;
+  *right += border.right;
+  *top += border.top;
+  *bottom += border.bottom;
+}
+
+static void moz_gtk_add_style_padding(GtkStyleContext* style, gint* left,
+                                      gint* top, gint* right, gint* bottom) {
+  GtkBorder padding;
+
+  gtk_style_context_get_padding(style, gtk_style_context_get_state(style),
+                                &padding);
+
+  *left += padding.left;
+  *right += padding.right;
+  *top += padding.top;
+  *bottom += padding.bottom;
+}
+
+static void moz_gtk_add_margin_border_padding(GtkStyleContext* style,
+                                              gint* left, gint* top,
+                                              gint* right, gint* bottom) {
+  moz_gtk_add_style_margin(style, left, top, right, bottom);
+  moz_gtk_add_style_border(style, left, top, right, bottom);
+  moz_gtk_add_style_padding(style, left, top, right, bottom);
+}
+
+static void moz_gtk_add_border_padding(GtkStyleContext* style, gint* left,
+                                       gint* top, gint* right, gint* bottom) {
+  moz_gtk_add_style_border(style, left, top, right, bottom);
+  moz_gtk_add_style_padding(style, left, top, right, bottom);
+}
+
+// In case there's an error in Gtk theme and preferred size is zero,
+// return some sane values to pass mozilla automation tests.
+// It should not happen in real-life.
+#define MIN_WIDGET_SIZE 10
+static void moz_gtk_sanity_preferred_size(GtkRequisition* requisition) {
+  if (requisition->width <= 0) {
+    requisition->width = MIN_WIDGET_SIZE;
+  }
+  if (requisition->height <= 0) {
+    requisition->height = MIN_WIDGET_SIZE;
+  }
+}
+
+// GetStateFlagsFromGtkWidgetState() can be safely used for the specific
+// GtkWidgets that set both prelight and active flags.  For other widgets,
+// either the GtkStateFlags or Gecko's GtkWidgetState need to be carefully
+// adjusted to match GTK behavior.  Although GTK sets insensitive and focus
+// flags in the generic GtkWidget base class, GTK adds prelight and active
+// flags only to widgets that are expected to demonstrate prelight or active
+// states.  This contrasts with HTML where any element may have :active and
+// :hover states, and so Gecko's GtkStateFlags do not necessarily map to GTK
+// flags.  Failure to restrict the flags in the same way as GTK can cause
+// generic CSS selectors from some themes to unintentionally match elements
+// that are not expected to change appearance on hover or mouse-down.
+static GtkStateFlags GetStateFlagsFromGtkWidgetState(GtkWidgetState* state) {
+  GtkStateFlags stateFlags = GTK_STATE_FLAG_NORMAL;
+
+  if (state->disabled)
+    stateFlags = GTK_STATE_FLAG_INSENSITIVE;
+  else {
+    if (state->depressed || state->active)
+      stateFlags =
+          static_cast<GtkStateFlags>(stateFlags | GTK_STATE_FLAG_ACTIVE);
+    if (state->inHover)
+      stateFlags =
+          static_cast<GtkStateFlags>(stateFlags | GTK_STATE_FLAG_PRELIGHT);
+    if (state->focused)
+      stateFlags =
+          static_cast<GtkStateFlags>(stateFlags | GTK_STATE_FLAG_FOCUSED);
+    if (state->backdrop)
+      stateFlags =
+          static_cast<GtkStateFlags>(stateFlags | GTK_STATE_FLAG_BACKDROP);
+  }
+
+  return stateFlags;
+}
+
+static GtkStateFlags GetStateFlagsFromGtkTabFlags(GtkTabFlags flags) {
+  return ((flags & MOZ_GTK_TAB_SELECTED) == 0) ? GTK_STATE_FLAG_NORMAL
+                                               : GTK_STATE_FLAG_ACTIVE;
+}
+
+gint moz_gtk_init() {
+  if (gtk_major_version > 3 ||
+      (gtk_major_version == 3 && gtk_minor_version >= 14))
+    checkbox_check_state = GTK_STATE_FLAG_CHECKED;
+  else
+    checkbox_check_state = GTK_STATE_FLAG_ACTIVE;
+
+  moz_gtk_refresh();
+
+  return MOZ_GTK_SUCCESS;
+}
+
+void moz_gtk_refresh() {
+  if (gtk_check_version(3, 20, 0) != nullptr) {
+    // Deprecated for Gtk >= 3.20+
+    GtkStyleContext* style = GetStyleContext(MOZ_GTK_TAB_TOP);
+    gtk_style_context_get_style(style, "has-tab-gap", &notebook_has_tab_gap,
+                                NULL);
+  } else {
+    notebook_has_tab_gap = true;
+  }
+
+  sCheckboxMetrics.initialized = false;
+  sRadioMetrics.initialized = false;
+  sMenuCheckboxMetrics.initialized = false;
+  sMenuRadioMetrics.initialized = false;
+  sToolbarMetrics.initialized = false;
+  sToplevelWindowDecorationSize.initialized = false;
+  sPopupWindowDecorationSize.initialized = false;
+
+  /* This will destroy all of our widgets */
+  ResetWidgetCache();
+}
+
+static gint moz_gtk_get_focus_outline_size(GtkStyleContext* style,
+                                           gint* focus_h_width,
+                                           gint* focus_v_width) {
+  GtkBorder border;
+  gtk_style_context_get_border(style, gtk_style_context_get_state(style),
+                               &border);
+  *focus_h_width = border.left;
+  *focus_v_width = border.top;
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_focus_outline_size(gint* focus_h_width, gint* focus_v_width) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_ENTRY);
+  moz_gtk_get_focus_outline_size(style, focus_h_width, focus_v_width);
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUITEM);
+  gtk_style_context_get_style(style, "horizontal-padding", horizontal_padding,
+                              nullptr);
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_checkmenuitem_get_horizontal_padding(gint* horizontal_padding) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_CHECKMENUITEM);
+  gtk_style_context_get_style(style, "horizontal-padding", horizontal_padding,
+                              nullptr);
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_button_get_default_overflow(gint* border_top, gint* border_left,
+                                         gint* border_bottom,
+                                         gint* border_right) {
+  GtkBorder* default_outside_border;
+
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON);
+  gtk_style_context_get_style(style, "default-outside-border",
+                              &default_outside_border, NULL);
+
+  if (default_outside_border) {
+    *border_top = default_outside_border->top;
+    *border_left = default_outside_border->left;
+    *border_bottom = default_outside_border->bottom;
+    *border_right = default_outside_border->right;
+    gtk_border_free(default_outside_border);
+  } else {
+    *border_top = *border_left = *border_bottom = *border_right = 0;
+  }
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_button_get_default_border(gint* border_top,
+                                              gint* border_left,
+                                              gint* border_bottom,
+                                              gint* border_right) {
+  GtkBorder* default_border;
+
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON);
+  gtk_style_context_get_style(style, "default-border", &default_border, NULL);
+
+  if (default_border) {
+    *border_top = default_border->top;
+    *border_left = default_border->left;
+    *border_bottom = default_border->bottom;
+    *border_right = default_border->right;
+    gtk_border_free(default_border);
+  } else {
+    /* see gtkbutton.c */
+    *border_top = *border_left = *border_bottom = *border_right = 1;
+  }
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_splitter_get_metrics(gint orientation, gint* size) {
+  GtkStyleContext* style;
+  if (orientation == GTK_ORIENTATION_HORIZONTAL) {
+    style = GetStyleContext(MOZ_GTK_SPLITTER_HORIZONTAL);
+  } else {
+    style = GetStyleContext(MOZ_GTK_SPLITTER_VERTICAL);
+  }
+  gtk_style_context_get_style(style, "handle_size", size, NULL);
+  return MOZ_GTK_SUCCESS;
+}
+
+static void CalculateToolbarButtonMetrics(WidgetNodeType aAppearance,
+                                          ToolbarButtonGTKMetrics* aMetrics) {
+  gint iconWidth, iconHeight;
+  if (!gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &iconWidth, &iconHeight)) {
+    NS_WARNING("Failed to get Gtk+ icon size for titlebar button!");
+
+    // Use some reasonable fallback size
+    iconWidth = 16;
+    iconHeight = 16;
+  }
+
+  GtkStyleContext* style = GetStyleContext(aAppearance);
+  gint width = 0, height = 0;
+  if (gtk_check_version(3, 20, 0) == nullptr) {
+    gtk_style_context_get(style, gtk_style_context_get_state(style),
+                          "min-width", &width, "min-height", &height, NULL);
+  }
+
+  // Cover cases when min-width/min-height is not set, it's invalid
+  // or we're running on Gtk+ < 3.20.
+  if (width < iconWidth) width = iconWidth;
+  if (height < iconHeight) height = iconHeight;
+
+  gint left = 0, top = 0, right = 0, bottom = 0;
+  moz_gtk_add_border_padding(style, &left, &top, &right, &bottom);
+
+  // Button size is calculated as min-width/height + border/padding.
+  width += left + right;
+  height += top + bottom;
+
+  // Place icon at button center.
+  aMetrics->iconXPosition = (width - iconWidth) / 2;
+  aMetrics->iconYPosition = (height - iconHeight) / 2;
+
+  aMetrics->minSizeWithBorderMargin.width = width;
+  aMetrics->minSizeWithBorderMargin.height = height;
+}
+
+// We support LTR layout only here for now.
+static void CalculateToolbarButtonSpacing(WidgetNodeType aAppearance,
+                                          ToolbarButtonGTKMetrics* aMetrics) {
+  GtkStyleContext* style = GetStyleContext(aAppearance);
+  gtk_style_context_get_margin(style, gtk_style_context_get_state(style),
+                               &aMetrics->buttonMargin);
+
+  // Get titlebar spacing, a default one is 6 pixels (gtk/gtkheaderbar.c)
+  gint buttonSpacing = 6;
+  g_object_get(GetWidget(MOZ_GTK_HEADER_BAR), "spacing", &buttonSpacing,
+               nullptr);
+
+  // We apply spacing as a margin equally to both adjacent buttons.
+  buttonSpacing /= 2;
+
+  if (!aMetrics->firstButton) {
+    aMetrics->buttonMargin.left += buttonSpacing;
+  }
+  if (!aMetrics->lastButton) {
+    aMetrics->buttonMargin.right += buttonSpacing;
+  }
+
+  aMetrics->minSizeWithBorderMargin.width +=
+      aMetrics->buttonMargin.right + aMetrics->buttonMargin.left;
+  aMetrics->minSizeWithBorderMargin.height +=
+      aMetrics->buttonMargin.top + aMetrics->buttonMargin.bottom;
+}
+
+size_t GetGtkHeaderBarButtonLayout(Span<ButtonLayout> aButtonLayout,
+                                   bool* aReversedButtonsPlacement) {
+  gchar* decorationLayoutSetting = nullptr;
+  GtkSettings* settings = gtk_settings_get_default();
+  g_object_get(settings, "gtk-decoration-layout", &decorationLayoutSetting,
+               nullptr);
+  auto free = mozilla::MakeScopeExit([&] { g_free(decorationLayoutSetting); });
+
+  // Use a default layout
+  const gchar* decorationLayout = "menu:minimize,maximize,close";
+  if (decorationLayoutSetting) {
+    decorationLayout = decorationLayoutSetting;
+  }
+
+  // "minimize,maximize,close:" layout means buttons are on the opposite
+  // titlebar side. close button is always there.
+  if (aReversedButtonsPlacement) {
+    const char* closeButton = strstr(decorationLayout, "close");
+    const char* separator = strchr(decorationLayout, ':');
+    *aReversedButtonsPlacement =
+        closeButton && separator && closeButton < separator;
+  }
+
+  // We check what position a button string is stored in decorationLayout.
+  //
+  // decorationLayout gets its value from the GNOME preference:
+  // org.gnome.desktop.vm.preferences.button-layout via the
+  // gtk-decoration-layout property.
+  //
+  // Documentation of the gtk-decoration-layout property can be found here:
+  // https://developer.gnome.org/gtk3/stable/GtkSettings.html#GtkSettings--gtk-decoration-layout
+  if (aButtonLayout.IsEmpty()) {
+    return 0;
+  }
+
+  nsDependentCSubstring layout(decorationLayout, strlen(decorationLayout));
+
+  size_t activeButtons = 0;
+  for (const auto& part : layout.Split(':')) {
+    for (const auto& button : part.Split(',')) {
+      if (button.EqualsLiteral("close")) {
+        aButtonLayout[activeButtons++] = {MOZ_GTK_HEADER_BAR_BUTTON_CLOSE};
+      } else if (button.EqualsLiteral("minimize")) {
+        aButtonLayout[activeButtons++] = {MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE};
+      } else if (button.EqualsLiteral("maximize")) {
+        aButtonLayout[activeButtons++] = {MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE};
+      }
+      if (activeButtons == aButtonLayout.Length()) {
+        return activeButtons;
+      }
+    }
+  }
+  return activeButtons;
+}
+
+static void EnsureToolbarMetrics() {
+  if (!sToolbarMetrics.initialized) {
+    // Make sure we have clean cache after theme reset, etc.
+    memset(&sToolbarMetrics, 0, sizeof(sToolbarMetrics));
+
+    // Calculate titlebar button visibility and positions.
+    ButtonLayout aButtonLayout[TOOLBAR_BUTTONS];
+    size_t activeButtonNums =
+        GetGtkHeaderBarButtonLayout(Span(aButtonLayout), nullptr);
+
+    for (size_t i = 0; i < activeButtonNums; i++) {
+      int buttonIndex =
+          (aButtonLayout[i].mType - MOZ_GTK_HEADER_BAR_BUTTON_CLOSE);
+      ToolbarButtonGTKMetrics* metrics = sToolbarMetrics.button + buttonIndex;
+      metrics->visible = true;
+      // Mark first button
+      if (!i) {
+        metrics->firstButton = true;
+      }
+      // Mark last button.
+      if (i == (activeButtonNums - 1)) {
+        metrics->lastButton = true;
+      }
+
+      CalculateToolbarButtonMetrics(aButtonLayout[i].mType, metrics);
+      CalculateToolbarButtonSpacing(aButtonLayout[i].mType, metrics);
+    }
+
+    sToolbarMetrics.initialized = true;
+  }
+}
+
+const ToolbarButtonGTKMetrics* GetToolbarButtonMetrics(
+    WidgetNodeType aAppearance) {
+  EnsureToolbarMetrics();
+
+  int buttonIndex = (aAppearance - MOZ_GTK_HEADER_BAR_BUTTON_CLOSE);
+  NS_ASSERTION(buttonIndex >= 0 && buttonIndex <= TOOLBAR_BUTTONS,
+               "GetToolbarButtonMetrics(): Wrong titlebar button!");
+  return sToolbarMetrics.button + buttonIndex;
+}
+
+static gint moz_gtk_window_paint(cairo_t* cr, GdkRectangle* rect,
+                                 GtkTextDirection direction) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW, direction);
+
+  gtk_style_context_save(style);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND);
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_style_context_restore(style);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_button_paint(cairo_t* cr, const GdkRectangle* rect,
+                                 GtkWidgetState* state, GtkReliefStyle relief,
+                                 GtkWidget* widget,
+                                 GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style = gtk_widget_get_style_context(widget);
+  gint x = rect->x, y = rect->y, width = rect->width, height = rect->height;
+
+  gtk_widget_set_direction(widget, direction);
+
+  gtk_style_context_save(style);
+  StyleContextSetScale(style, state->scale);
+  gtk_style_context_set_state(style, state_flags);
+
+  if (state->isDefault && relief == GTK_RELIEF_NORMAL && !state->focused &&
+      !(state_flags & GTK_STATE_FLAG_PRELIGHT)) {
+    /* handle default borders both outside and inside the button */
+    gint default_top, default_left, default_bottom, default_right;
+    moz_gtk_button_get_default_overflow(&default_top, &default_left,
+                                        &default_bottom, &default_right);
+    x -= default_left;
+    y -= default_top;
+    width += default_left + default_right;
+    height += default_top + default_bottom;
+    gtk_render_background(style, cr, x, y, width, height);
+    gtk_render_frame(style, cr, x, y, width, height);
+    moz_gtk_button_get_default_border(&default_top, &default_left,
+                                      &default_bottom, &default_right);
+    x += default_left;
+    y += default_top;
+    width -= (default_left + default_right);
+    height -= (default_top + default_bottom);
+  } else if (relief != GTK_RELIEF_NONE || state->depressed ||
+             (state_flags & GTK_STATE_FLAG_PRELIGHT)) {
+    /* the following line can trigger an assertion (Crux theme)
+       file ../../gdk/gdkwindow.c: line 1846 (gdk_window_clear_area):
+       assertion `GDK_IS_WINDOW (window)' failed */
+    gtk_render_background(style, cr, x, y, width, height);
+    gtk_render_frame(style, cr, x, y, width, height);
+  }
+
+  if (state->focused) {
+    GtkBorder border;
+    gtk_style_context_get_border(style, state_flags, &border);
+    x += border.left;
+    y += border.top;
+    width -= (border.left + border.right);
+    height -= (border.top + border.bottom);
+    gtk_render_focus(style, cr, x, y, width, height);
+  }
+  gtk_style_context_restore(style);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_header_bar_button_paint(cairo_t* cr,
+                                            const GdkRectangle* aRect,
+                                            GtkWidgetState* state,
+                                            GtkReliefStyle relief,
+                                            WidgetNodeType aIconWidgetType,
+                                            GtkTextDirection direction) {
+  WidgetNodeType buttonWidgetType =
+      (aIconWidgetType == MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE)
+          ? MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE
+          : aIconWidgetType;
+
+  GdkRectangle rect = *aRect;
+  // We need to inset our calculated margin because it also
+  // contains titlebar button spacing.
+  const ToolbarButtonGTKMetrics* metrics =
+      GetToolbarButtonMetrics(buttonWidgetType);
+  Inset(&rect, metrics->buttonMargin);
+
+  GtkWidget* buttonWidget = GetWidget(buttonWidgetType);
+  moz_gtk_button_paint(cr, &rect, state, relief, buttonWidget, direction);
+
+  GtkWidget* iconWidget =
+      gtk_bin_get_child(GTK_BIN(GetWidget(aIconWidgetType)));
+  cairo_surface_t* surface = GetWidgetIconSurface(iconWidget, state->scale);
+
+  if (surface) {
+    GtkStyleContext* style = gtk_widget_get_style_context(buttonWidget);
+    GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+
+    gtk_style_context_save(style);
+    StyleContextSetScale(style, state->scale);
+    gtk_style_context_set_state(style, state_flags);
+
+    const ToolbarButtonGTKMetrics* metrics =
+        GetToolbarButtonMetrics(buttonWidgetType);
+
+    /* This is available since Gtk+ 3.10 as well as GtkHeaderBar */
+    gtk_render_icon_surface(style, cr, surface, rect.x + metrics->iconXPosition,
+                            rect.y + metrics->iconYPosition);
+    gtk_style_context_restore(style);
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_toggle_paint(cairo_t* cr, GdkRectangle* rect,
+                                 GtkWidgetState* state, gboolean selected,
+                                 gboolean inconsistent, gboolean isradio,
+                                 GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  gint x, y, width, height;
+  GtkStyleContext* style;
+
+  // We need to call this before GetStyleContext, because otherwise we would
+  // reset state flags
+  const ToggleGTKMetrics* metrics =
+      GetToggleMetrics(isradio ? MOZ_GTK_RADIOBUTTON : MOZ_GTK_CHECKBUTTON);
+  // Clamp the rect and paint it center aligned in the rect.
+  x = rect->x;
+  y = rect->y;
+  width = rect->width;
+  height = rect->height;
+
+  if (rect->width < rect->height) {
+    y = rect->y + (rect->height - rect->width) / 2;
+    height = rect->width;
+  }
+
+  if (rect->height < rect->width) {
+    x = rect->x + (rect->width - rect->height) / 2;
+    width = rect->height;
+  }
+
+  if (selected)
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags | checkbox_check_state);
+
+  if (inconsistent)
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags | GTK_STATE_FLAG_INCONSISTENT);
+
+  style = GetStyleContext(isradio ? MOZ_GTK_RADIOBUTTON : MOZ_GTK_CHECKBUTTON,
+                          state->scale, direction, state_flags);
+
+  if (gtk_check_version(3, 20, 0) == nullptr) {
+    gtk_render_background(style, cr, x, y, width, height);
+    gtk_render_frame(style, cr, x, y, width, height);
+    // Indicator is inset by the toggle's padding and border.
+    gint indicator_x = x + metrics->borderAndPadding.left;
+    gint indicator_y = y + metrics->borderAndPadding.top;
+    gint indicator_width = metrics->minSizeWithBorder.width -
+                           metrics->borderAndPadding.left -
+                           metrics->borderAndPadding.right;
+    gint indicator_height = metrics->minSizeWithBorder.height -
+                            metrics->borderAndPadding.top -
+                            metrics->borderAndPadding.bottom;
+    if (isradio) {
+      gtk_render_option(style, cr, indicator_x, indicator_y, indicator_width,
+                        indicator_height);
+    } else {
+      gtk_render_check(style, cr, indicator_x, indicator_y, indicator_width,
+                       indicator_height);
+    }
+  } else {
+    if (isradio) {
+      gtk_render_option(style, cr, x, y, width, height);
+    } else {
+      gtk_render_check(style, cr, x, y, width, height);
+    }
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint calculate_button_inner_rect(GtkWidget* button,
+                                        const GdkRectangle* rect,
+                                        GdkRectangle* inner_rect,
+                                        GtkTextDirection direction) {
+  GtkStyleContext* style;
+  GtkBorder border;
+  GtkBorder padding = {0, 0, 0, 0};
+
+  style = gtk_widget_get_style_context(button);
+
+  /* This mirrors gtkbutton's child positioning */
+  gtk_style_context_get_border(style, gtk_style_context_get_state(style),
+                               &border);
+  gtk_style_context_get_padding(style, gtk_style_context_get_state(style),
+                                &padding);
+
+  inner_rect->x = rect->x + border.left + padding.left;
+  inner_rect->y = rect->y + padding.top + border.top;
+  inner_rect->width =
+      MAX(1, rect->width - padding.left - padding.right - border.left * 2);
+  inner_rect->height =
+      MAX(1, rect->height - padding.top - padding.bottom - border.top * 2);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint calculate_arrow_rect(GtkWidget* arrow, GdkRectangle* rect,
+                                 GdkRectangle* arrow_rect,
+                                 GtkTextDirection direction) {
+  /* defined in gtkarrow.c */
+  gfloat arrow_scaling = 0.7;
+  gfloat xalign, xpad;
+  gint extent;
+  gint mxpad, mypad;
+  gfloat mxalign, myalign;
+  GtkMisc* misc = GTK_MISC(arrow);
+
+  gtk_style_context_get_style(gtk_widget_get_style_context(arrow),
+                              "arrow_scaling", &arrow_scaling, NULL);
+
+  gtk_misc_get_padding(misc, &mxpad, &mypad);
+  extent = MIN((rect->width - mxpad * 2), (rect->height - mypad * 2)) *
+           arrow_scaling;
+
+  gtk_misc_get_alignment(misc, &mxalign, &myalign);
+
+  xalign = direction == GTK_TEXT_DIR_LTR ? mxalign : 1.0 - mxalign;
+  xpad = mxpad + (rect->width - extent) * xalign;
+
+  arrow_rect->x = direction == GTK_TEXT_DIR_LTR ? floor(rect->x + xpad)
+                                                : ceil(rect->x + xpad);
+  arrow_rect->y = floor(rect->y + mypad + ((rect->height - extent) * myalign));
+
+  arrow_rect->width = arrow_rect->height = extent;
+
+  return MOZ_GTK_SUCCESS;
+}
+
+/**
+ * Get minimum widget size as sum of margin, padding, border and
+ * min-width/min-height.
+ */
+static void moz_gtk_get_widget_min_size(GtkStyleContext* style, int* width,
+                                        int* height) {
+  GtkStateFlags state_flags = gtk_style_context_get_state(style);
+  gtk_style_context_get(style, state_flags, "min-height", height, "min-width",
+                        width, nullptr);
+
+  GtkBorder border, padding, margin;
+  gtk_style_context_get_border(style, state_flags, &border);
+  gtk_style_context_get_padding(style, state_flags, &padding);
+  gtk_style_context_get_margin(style, state_flags, &margin);
+
+  *width += border.left + border.right + margin.left + margin.right +
+            padding.left + padding.right;
+  *height += border.top + border.bottom + margin.top + margin.bottom +
+             padding.top + padding.bottom;
+}
+
+static void Inset(GdkRectangle* rect, const GtkBorder& aBorder) {
+  rect->x += aBorder.left;
+  rect->y += aBorder.top;
+  rect->width -= aBorder.left + aBorder.right;
+  rect->height -= aBorder.top + aBorder.bottom;
+}
+
+// Inset a rectangle by the margins specified in a style context.
+static void InsetByMargin(GdkRectangle* rect, GtkStyleContext* style) {
+  GtkBorder margin;
+  gtk_style_context_get_margin(style, gtk_style_context_get_state(style),
+                               &margin);
+  Inset(rect, margin);
+}
+
+// Inset a rectangle by the border and padding specified in a style context.
+static void InsetByBorderPadding(GdkRectangle* rect, GtkStyleContext* style) {
+  GtkStateFlags state = gtk_style_context_get_state(style);
+  GtkBorder padding, border;
+
+  gtk_style_context_get_padding(style, state, &padding);
+  Inset(rect, padding);
+  gtk_style_context_get_border(style, state, &border);
+  Inset(rect, border);
+}
+
+static void moz_gtk_draw_styled_frame(GtkStyleContext* style, cairo_t* cr,
+                                      const GdkRectangle* aRect,
+                                      bool drawFocus) {
+  GdkRectangle rect = *aRect;
+
+  InsetByMargin(&rect, style);
+
+  gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
+  gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height);
+  if (drawFocus) {
+    gtk_render_focus(style, cr, rect.x, rect.y, rect.width, rect.height);
+  }
+}
+
+static gint moz_gtk_inner_spin_paint(cairo_t* cr, GdkRectangle* rect,
+                                     GtkWidgetState* state,
+                                     GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_SPINBUTTON, state->scale, direction,
+                      GetStateFlagsFromGtkWidgetState(state));
+
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  /* hard code these values */
+  GdkRectangle arrow_rect;
+  arrow_rect.width = 6;
+  arrow_rect.height = 6;
+
+  // align spin to the left
+  arrow_rect.x = rect->x;
+
+  // up button
+  arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 - 3;
+  gtk_render_arrow(style, cr, ARROW_UP, arrow_rect.x, arrow_rect.y,
+                   arrow_rect.width);
+
+  // down button
+  arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 + 3;
+  gtk_render_arrow(style, cr, ARROW_DOWN, arrow_rect.x, arrow_rect.y,
+                   arrow_rect.width);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_spin_paint(cairo_t* cr, GdkRectangle* rect,
+                               GtkWidgetState* state,
+                               GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_SPINBUTTON, state->scale, direction);
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_spin_updown_paint(cairo_t* cr, GdkRectangle* rect,
+                                      gboolean isDown, GtkWidgetState* state,
+                                      GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_SPINBUTTON, state->scale, direction,
+                      GetStateFlagsFromGtkWidgetState(state));
+
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  /* hard code these values */
+  GdkRectangle arrow_rect;
+  arrow_rect.width = 6;
+  arrow_rect.height = 6;
+  arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
+  arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
+  arrow_rect.y += isDown ? -1 : 1;
+
+  gtk_render_arrow(style, cr, isDown ? ARROW_DOWN : ARROW_UP, arrow_rect.x,
+                   arrow_rect.y, arrow_rect.width);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+/* See gtk_range_draw() for reference.
+ */
+static gint moz_gtk_scale_paint(cairo_t* cr, GdkRectangle* rect,
+                                GtkWidgetState* state, GtkOrientation flags,
+                                GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  gint x, y, width, height, min_width, min_height;
+  GtkStyleContext* style;
+  GtkBorder margin;
+
+  moz_gtk_get_scale_metrics(flags, &min_width, &min_height);
+
+  WidgetNodeType widget = (flags == GTK_ORIENTATION_HORIZONTAL)
+                              ? MOZ_GTK_SCALE_TROUGH_HORIZONTAL
+                              : MOZ_GTK_SCALE_TROUGH_VERTICAL;
+  style = GetStyleContext(widget, state->scale, direction, state_flags);
+  gtk_style_context_get_margin(style, state_flags, &margin);
+
+  // Clamp the dimension perpendicular to the direction that the slider crosses
+  // to the minimum size.
+  if (flags == GTK_ORIENTATION_HORIZONTAL) {
+    width = rect->width - (margin.left + margin.right);
+    height = min_height - (margin.top + margin.bottom);
+    x = rect->x + margin.left;
+    y = rect->y + (rect->height - height) / 2;
+  } else {
+    width = min_width - (margin.left + margin.right);
+    height = rect->height - (margin.top + margin.bottom);
+    x = rect->x + (rect->width - width) / 2;
+    y = rect->y + margin.top;
+  }
+
+  gtk_render_background(style, cr, x, y, width, height);
+  gtk_render_frame(style, cr, x, y, width, height);
+
+  if (state->focused)
+    gtk_render_focus(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_scale_thumb_paint(cairo_t* cr, GdkRectangle* rect,
+                                      GtkWidgetState* state,
+                                      GtkOrientation flags,
+                                      GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style;
+  gint thumb_width, thumb_height, x, y;
+
+  /* determine the thumb size, and position the thumb in the center in the
+   * opposite axis
+   */
+  if (flags == GTK_ORIENTATION_HORIZONTAL) {
+    moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_HORIZONTAL, &thumb_width,
+                                   &thumb_height);
+    x = rect->x;
+    y = rect->y + (rect->height - thumb_height) / 2;
+  } else {
+    moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &thumb_height,
+                                   &thumb_width);
+    x = rect->x + (rect->width - thumb_width) / 2;
+    y = rect->y;
+  }
+
+  WidgetNodeType widget = (flags == GTK_ORIENTATION_HORIZONTAL)
+                              ? MOZ_GTK_SCALE_THUMB_HORIZONTAL
+                              : MOZ_GTK_SCALE_THUMB_VERTICAL;
+  style = GetStyleContext(widget, state->scale, direction, state_flags);
+  gtk_render_slider(style, cr, x, y, thumb_width, thumb_height, flags);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_gripper_paint(cairo_t* cr, GdkRectangle* rect,
+                                  GtkWidgetState* state,
+                                  GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_GRIPPER, state->scale, direction,
+                      GetStateFlagsFromGtkWidgetState(state));
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_hpaned_paint(cairo_t* cr, GdkRectangle* rect,
+                                 GtkWidgetState* state) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_SPLITTER_SEPARATOR_HORIZONTAL, state->scale,
+                      GTK_TEXT_DIR_LTR, GetStateFlagsFromGtkWidgetState(state));
+  gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_vpaned_paint(cairo_t* cr, GdkRectangle* rect,
+                                 GtkWidgetState* state) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_SPLITTER_SEPARATOR_VERTICAL, state->scale,
+                      GTK_TEXT_DIR_LTR, GetStateFlagsFromGtkWidgetState(state));
+  gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+// See gtk_entry_draw() for reference.
+static gint moz_gtk_entry_paint(cairo_t* cr, const GdkRectangle* aRect,
+                                GtkWidgetState* state, GtkStyleContext* style,
+                                WidgetNodeType widget) {
+  // StyleAppearance::FocusOutline
+  int draw_focus_outline_only = state->depressed;
+  GdkRectangle rect = *aRect;
+
+  if (draw_focus_outline_only) {
+    // Inflate the given 'rect' with the focus outline size.
+    gint h, v;
+    moz_gtk_get_focus_outline_size(style, &h, &v);
+    rect.x -= h;
+    rect.width += 2 * h;
+    rect.y -= v;
+    rect.height += 2 * v;
+  } else {
+    gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
+  }
+
+  // Paint the border, except for 'menulist-textfield' that isn't focused:
+  if (widget != MOZ_GTK_DROPDOWN_ENTRY || state->focused) {
+    gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height);
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_text_view_paint(cairo_t* cr, GdkRectangle* aRect,
+                                    GtkWidgetState* state,
+                                    GtkTextDirection direction) {
+  // GtkTextView and GtkScrolledWindow do not set active and prelight flags.
+  // The use of focus with MOZ_GTK_SCROLLED_WINDOW here is questionable
+  // because a parent widget will not have focus when its child GtkTextView
+  // has focus, but perhaps this may help identify a focused textarea with
+  // some themes as GtkTextView backgrounds do not typically render
+  // differently with focus.
+  GtkStateFlags state_flags = state->disabled  ? GTK_STATE_FLAG_INSENSITIVE
+                              : state->focused ? GTK_STATE_FLAG_FOCUSED
+                                               : GTK_STATE_FLAG_NORMAL;
+
+  GtkStyleContext* style_frame = GetStyleContext(
+      MOZ_GTK_SCROLLED_WINDOW, state->scale, direction, state_flags);
+  gtk_render_frame(style_frame, cr, aRect->x, aRect->y, aRect->width,
+                   aRect->height);
+
+  GdkRectangle rect = *aRect;
+  InsetByBorderPadding(&rect, style_frame);
+
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_TEXT_VIEW, state->scale, direction, state_flags);
+  gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
+  // There is a separate "text" window, which usually provides the
+  // background behind the text.  However, this is transparent in Ambiance
+  // for GTK 3.20, in which case the MOZ_GTK_TEXT_VIEW background is
+  // visible.
+  style = GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT, state->scale, direction,
+                          state_flags);
+  gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_treeview_paint(cairo_t* cr, GdkRectangle* rect,
+                                   GtkWidgetState* state,
+                                   GtkTextDirection direction) {
+  gint xthickness, ythickness;
+  GtkStyleContext* style;
+  GtkStyleContext* style_tree;
+  GtkStateFlags state_flags;
+  GtkBorder border;
+
+  /* only handle disabled and normal states, otherwise the whole background
+   * area will be painted differently with other states */
+  state_flags =
+      state->disabled ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL;
+
+  style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, state->scale, direction);
+  gtk_style_context_get_border(style, state_flags, &border);
+  xthickness = border.left;
+  ythickness = border.top;
+
+  style_tree = GetStyleContext(MOZ_GTK_TREEVIEW_VIEW, state->scale, direction);
+  gtk_render_background(style_tree, cr, rect->x + xthickness,
+                        rect->y + ythickness, rect->width - 2 * xthickness,
+                        rect->height - 2 * ythickness);
+
+  style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, state->scale, direction);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_tree_header_cell_paint(cairo_t* cr,
+                                           const GdkRectangle* aRect,
+                                           GtkWidgetState* state,
+                                           gboolean isSorted,
+                                           GtkTextDirection direction) {
+  moz_gtk_button_paint(cr, aRect, state, GTK_RELIEF_NORMAL,
+                       GetWidget(MOZ_GTK_TREE_HEADER_CELL), direction);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_tree_header_sort_arrow_paint(cairo_t* cr,
+                                                 GdkRectangle* rect,
+                                                 GtkWidgetState* state,
+                                                 GtkArrowType arrow_type,
+                                                 GtkTextDirection direction) {
+  GdkRectangle arrow_rect;
+  gdouble arrow_angle;
+  GtkStyleContext* style;
+
+  /* hard code these values */
+  arrow_rect.width = 11;
+  arrow_rect.height = 11;
+  arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
+  arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
+  style = GetStyleContext(MOZ_GTK_TREE_HEADER_SORTARROW, state->scale,
+                          direction, GetStateFlagsFromGtkWidgetState(state));
+  switch (arrow_type) {
+    case GTK_ARROW_LEFT:
+      arrow_angle = ARROW_LEFT;
+      break;
+    case GTK_ARROW_RIGHT:
+      arrow_angle = ARROW_RIGHT;
+      break;
+    case GTK_ARROW_DOWN:
+      arrow_angle = ARROW_DOWN;
+      break;
+    default:
+      arrow_angle = ARROW_UP;
+      break;
+  }
+  if (arrow_type != GTK_ARROW_NONE)
+    gtk_render_arrow(style, cr, arrow_angle, arrow_rect.x, arrow_rect.y,
+                     arrow_rect.width);
+  return MOZ_GTK_SUCCESS;
+}
+
+/* See gtk_expander_paint() for reference.
+ */
+static gint moz_gtk_treeview_expander_paint(cairo_t* cr, GdkRectangle* rect,
+                                            GtkWidgetState* state,
+                                            GtkExpanderStyle expander_state,
+                                            GtkTextDirection direction) {
+  /* Because the frame we get is of the entire treeview, we can't get the
+   * precise event state of one expander, thus rendering hover and active
+   * feedback useless. */
+  GtkStateFlags state_flags =
+      state->disabled ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL;
+
+  if (state->inHover)
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags | GTK_STATE_FLAG_PRELIGHT);
+  if (state->selected)
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags | GTK_STATE_FLAG_SELECTED);
+
+  /* GTK_STATE_FLAG_ACTIVE controls expanded/colapsed state rendering
+   * in gtk_render_expander()
+   */
+  if (expander_state == GTK_EXPANDER_EXPANDED)
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags | checkbox_check_state);
+  else
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags & ~(checkbox_check_state));
+
+  GtkStyleContext* style = GetStyleContext(
+      MOZ_GTK_TREEVIEW_EXPANDER, state->scale, direction, state_flags);
+  gtk_render_expander(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+/* See gtk_separator_draw() for reference.
+ */
+static gint moz_gtk_combo_box_paint(cairo_t* cr, const GdkRectangle* aRect,
+                                    GtkWidgetState* state,
+                                    GtkTextDirection direction) {
+  GdkRectangle arrow_rect, real_arrow_rect;
+  gint separator_width;
+  gboolean wide_separators;
+  GtkStyleContext* style;
+  GtkRequisition arrow_req;
+
+  GtkWidget* comboBoxButton = GetWidget(MOZ_GTK_COMBOBOX_BUTTON);
+  GtkWidget* comboBoxArrow = GetWidget(MOZ_GTK_COMBOBOX_ARROW);
+
+  /* Also sets the direction on gComboBoxButtonWidget, which is then
+   * inherited by the separator and arrow */
+  moz_gtk_button_paint(cr, aRect, state, GTK_RELIEF_NORMAL, comboBoxButton,
+                       direction);
+
+  calculate_button_inner_rect(comboBoxButton, aRect, &arrow_rect, direction);
+  /* Now arrow_rect contains the inner rect ; we want to correct the width
+   * to what the arrow needs (see gtk_combo_box_size_allocate) */
+  gtk_widget_get_preferred_size(comboBoxArrow, NULL, &arrow_req);
+  moz_gtk_sanity_preferred_size(&arrow_req);
+
+  if (direction == GTK_TEXT_DIR_LTR)
+    arrow_rect.x += arrow_rect.width - arrow_req.width;
+  arrow_rect.width = arrow_req.width;
+
+  calculate_arrow_rect(comboBoxArrow, &arrow_rect, &real_arrow_rect, direction);
+
+  style = GetStyleContext(MOZ_GTK_COMBOBOX_ARROW, state->scale);
+  gtk_render_arrow(style, cr, ARROW_DOWN, real_arrow_rect.x, real_arrow_rect.y,
+                   real_arrow_rect.width);
+
+  /* If there is no separator in the theme, there's nothing left to do. */
+  GtkWidget* widget = GetWidget(MOZ_GTK_COMBOBOX_SEPARATOR);
+  if (!widget) return MOZ_GTK_SUCCESS;
+  style = gtk_widget_get_style_context(widget);
+  StyleContextSetScale(style, state->scale);
+  gtk_style_context_get_style(style, "wide-separators", &wide_separators,
+                              "separator-width", &separator_width, NULL);
+
+  if (wide_separators) {
+    if (direction == GTK_TEXT_DIR_LTR)
+      arrow_rect.x -= separator_width;
+    else
+      arrow_rect.x += arrow_rect.width;
+
+    gtk_render_frame(style, cr, arrow_rect.x, arrow_rect.y, separator_width,
+                     arrow_rect.height);
+  } else {
+    if (direction == GTK_TEXT_DIR_LTR) {
+      GtkBorder padding;
+      GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+      gtk_style_context_get_padding(style, state_flags, &padding);
+      arrow_rect.x -= padding.left;
+    } else
+      arrow_rect.x += arrow_rect.width;
+
+    gtk_render_line(style, cr, arrow_rect.x, arrow_rect.y, arrow_rect.x,
+                    arrow_rect.y + arrow_rect.height);
+  }
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_arrow_paint(cairo_t* cr, GdkRectangle* rect,
+                                GtkWidgetState* state, GtkArrowType arrow_type,
+                                GtkTextDirection direction) {
+  GdkRectangle arrow_rect;
+  gdouble arrow_angle;
+
+  if (direction == GTK_TEXT_DIR_RTL) {
+    if (arrow_type == GTK_ARROW_LEFT) {
+      arrow_type = GTK_ARROW_RIGHT;
+    } else if (arrow_type == GTK_ARROW_RIGHT) {
+      arrow_type = GTK_ARROW_LEFT;
+    }
+  }
+  switch (arrow_type) {
+    case GTK_ARROW_LEFT:
+      arrow_angle = ARROW_LEFT;
+      break;
+    case GTK_ARROW_RIGHT:
+      arrow_angle = ARROW_RIGHT;
+      break;
+    case GTK_ARROW_DOWN:
+      arrow_angle = ARROW_DOWN;
+      break;
+    default:
+      arrow_angle = ARROW_UP;
+      break;
+  }
+  if (arrow_type == GTK_ARROW_NONE) return MOZ_GTK_SUCCESS;
+
+  calculate_arrow_rect(GetWidget(MOZ_GTK_BUTTON_ARROW), rect, &arrow_rect,
+                       direction);
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON_ARROW, state->scale,
+                                           direction, state_flags);
+  gtk_render_arrow(style, cr, arrow_angle, arrow_rect.x, arrow_rect.y,
+                   arrow_rect.width);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_combo_box_entry_button_paint(cairo_t* cr,
+                                                 GdkRectangle* rect,
+                                                 GtkWidgetState* state,
+                                                 gboolean input_focus,
+                                                 GtkTextDirection direction) {
+  gint x_displacement, y_displacement;
+  GdkRectangle arrow_rect, real_arrow_rect;
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style;
+
+  GtkWidget* comboBoxEntry = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON);
+  moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL, comboBoxEntry,
+                       direction);
+  calculate_button_inner_rect(comboBoxEntry, rect, &arrow_rect, direction);
+
+  if (state_flags & GTK_STATE_FLAG_ACTIVE) {
+    style = gtk_widget_get_style_context(comboBoxEntry);
+    StyleContextSetScale(style, state->scale);
+    gtk_style_context_get_style(style, "child-displacement-x", &x_displacement,
+                                "child-displacement-y", &y_displacement, NULL);
+    arrow_rect.x += x_displacement;
+    arrow_rect.y += y_displacement;
+  }
+
+  calculate_arrow_rect(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_ARROW), &arrow_rect,
+                       &real_arrow_rect, direction);
+
+  style = GetStyleContext(MOZ_GTK_COMBOBOX_ENTRY_ARROW, state->scale);
+  gtk_render_arrow(style, cr, ARROW_DOWN, real_arrow_rect.x, real_arrow_rect.y,
+                   real_arrow_rect.width);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_container_paint(cairo_t* cr, GdkRectangle* rect,
+                                    GtkWidgetState* state,
+                                    WidgetNodeType widget_type,
+                                    GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style =
+      GetStyleContext(widget_type, state->scale, direction, state_flags);
+  /* this is for drawing a prelight box */
+  if (state_flags & GTK_STATE_FLAG_PRELIGHT) {
+    gtk_render_background(style, cr, rect->x, rect->y, rect->width,
+                          rect->height);
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_toggle_label_paint(cairo_t* cr, GdkRectangle* rect,
+                                       GtkWidgetState* state, gboolean isradio,
+                                       GtkTextDirection direction) {
+  if (!state->focused) return MOZ_GTK_SUCCESS;
+
+  GtkStyleContext* style = GetStyleContext(
+      isradio ? MOZ_GTK_RADIOBUTTON_CONTAINER : MOZ_GTK_CHECKBUTTON_CONTAINER,
+      state->scale, direction, GetStateFlagsFromGtkWidgetState(state));
+  gtk_render_focus(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_toolbar_paint(cairo_t* cr, GdkRectangle* rect,
+                                  GtkWidgetState* state,
+                                  GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_TOOLBAR, state->scale, direction);
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+/* See _gtk_toolbar_paint_space_line() for reference.
+ */
+static gint moz_gtk_toolbar_separator_paint(cairo_t* cr, GdkRectangle* rect,
+                                            GtkWidgetState* state,
+                                            GtkTextDirection direction) {
+  gint separator_width;
+  gint paint_width;
+  gboolean wide_separators;
+
+  /* Defined as constants in GTK+ 2.10.14 */
+  const double start_fraction = 0.2;
+  const double end_fraction = 0.8;
+
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR, state->scale);
+  gtk_style_context_get_style(style, "wide-separators", &wide_separators,
+                              "separator-width", &separator_width, NULL);
+
+  style = GetStyleContext(MOZ_GTK_TOOLBAR_SEPARATOR, state->scale, direction);
+  if (wide_separators) {
+    if (separator_width > rect->width) separator_width = rect->width;
+
+    gtk_render_frame(style, cr, rect->x + (rect->width - separator_width) / 2,
+                     rect->y + rect->height * start_fraction, separator_width,
+                     rect->height * (end_fraction - start_fraction));
+  } else {
+    GtkBorder padding;
+    gtk_style_context_get_padding(style, gtk_style_context_get_state(style),
+                                  &padding);
+
+    paint_width = padding.left;
+    if (paint_width > rect->width) paint_width = rect->width;
+
+    gtk_render_line(style, cr, rect->x + (rect->width - paint_width) / 2,
+                    rect->y + rect->height * start_fraction,
+                    rect->x + (rect->width - paint_width) / 2,
+                    rect->y + rect->height * end_fraction);
+  }
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_tooltip_paint(cairo_t* cr, const GdkRectangle* aRect,
+                                  GtkWidgetState* state,
+                                  GtkTextDirection direction) {
+  // Tooltip widget is made in GTK3 as following tree:
+  // Tooltip window
+  //   Horizontal Box
+  //     Icon (not supported by Firefox)
+  //     Label
+  // Each element can be fully styled by CSS of GTK theme.
+  // We have to draw all elements with appropriate offset and right dimensions.
+
+  // Tooltip drawing
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_TOOLTIP, state->scale, direction);
+  GdkRectangle rect = *aRect;
+  gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
+  gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height);
+
+  // Horizontal Box drawing
+  //
+  // The box element has hard-coded 6px margin-* GtkWidget properties, which
+  // are added between the window dimensions and the CSS margin box of the
+  // horizontal box.  The frame of the tooltip window is drawn in the
+  // 6px margin.
+  // For drawing Horizontal Box we have to inset drawing area by that 6px
+  // plus its CSS margin.
+  GtkStyleContext* boxStyle =
+      GetStyleContext(MOZ_GTK_TOOLTIP_BOX, state->scale, direction);
+
+  rect.x += 6;
+  rect.y += 6;
+  rect.width -= 12;
+  rect.height -= 12;
+
+  InsetByMargin(&rect, boxStyle);
+  gtk_render_background(boxStyle, cr, rect.x, rect.y, rect.width, rect.height);
+  gtk_render_frame(boxStyle, cr, rect.x, rect.y, rect.width, rect.height);
+
+  // Label drawing
+  InsetByBorderPadding(&rect, boxStyle);
+
+  GtkStyleContext* labelStyle =
+      GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL, state->scale, direction);
+  moz_gtk_draw_styled_frame(labelStyle, cr, &rect, false);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_resizer_paint(cairo_t* cr, GdkRectangle* rect,
+                                  GtkWidgetState* state,
+                                  GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_RESIZER, state->scale, GTK_TEXT_DIR_LTR,
+                      GetStateFlagsFromGtkWidgetState(state));
+
+  // Workaround unico not respecting the text direction for resizers.
+  // See bug 1174248.
+  cairo_save(cr);
+  if (direction == GTK_TEXT_DIR_RTL) {
+    cairo_matrix_t mat;
+    cairo_matrix_init_translate(&mat, 2 * rect->x + rect->width, 0);
+    cairo_matrix_scale(&mat, -1, 1);
+    cairo_transform(cr, &mat);
+  }
+
+  gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height);
+  cairo_restore(cr);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_frame_paint(cairo_t* cr, GdkRectangle* rect,
+                                GtkWidgetState* state,
+                                GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_FRAME, state->scale, direction);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_progressbar_paint(cairo_t* cr, GdkRectangle* rect,
+                                      GtkWidgetState* state,
+                                      GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_PROGRESS_TROUGH, state->scale, direction);
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_progress_chunk_paint(cairo_t* cr, GdkRectangle* rect,
+                                         GtkWidgetState* state,
+                                         GtkTextDirection direction,
+                                         WidgetNodeType widget) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_PROGRESS_CHUNK, state->scale, direction);
+
+  if (widget == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE ||
+      widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) {
+    /**
+     * The bar's size and the bar speed are set depending of the progress'
+     * size. These could also be constant for all progress bars easily.
+     */
+    gboolean vertical =
+        (widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE);
+
+    /* The size of the dimension we are going to use for the animation. */
+    const gint progressSize = vertical ? rect->height : rect->width;
+
+    /* The bar is using a fifth of the element size, based on GtkProgressBar
+     * activity-blocks property. */
+    const gint barSize = MAX(1, progressSize / 5);
+
+    /* Represents the travel that has to be done for a complete cycle. */
+    const gint travel = 2 * (progressSize - barSize);
+
+    /* period equals to travel / pixelsPerMillisecond
+     * where pixelsPerMillisecond equals progressSize / 1000.0.
+     * This is equivalent to 1600. */
+    static const guint period = 1600;
+    const gint t = PR_IntervalToMilliseconds(PR_IntervalNow()) % period;
+    const gint dx = travel * t / period;
+
+    if (vertical) {
+      rect->y += (dx < travel / 2) ? dx : travel - dx;
+      rect->height = barSize;
+    } else {
+      rect->x += (dx < travel / 2) ? dx : travel - dx;
+      rect->width = barSize;
+    }
+  }
+
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_get_tab_thickness(GtkStyleContext* style) {
+  if (!notebook_has_tab_gap)
+    return 0; /* tabs do not overdraw the tabpanel border with "no gap" style */
+
+  GtkBorder border;
+  gtk_style_context_get_border(style, gtk_style_context_get_state(style),
+                               &border);
+  if (border.top < 2) return 2; /* some themes don't set ythickness correctly */
+
+  return border.top;
+}
+
+gint moz_gtk_get_tab_thickness(WidgetNodeType aNodeType) {
+  GtkStyleContext* style = GetStyleContext(aNodeType);
+  int thickness = moz_gtk_get_tab_thickness(style);
+  return thickness;
+}
+
+/* actual small tabs */
+static gint moz_gtk_tab_paint(cairo_t* cr, GdkRectangle* rect,
+                              GtkWidgetState* state, GtkTabFlags flags,
+                              GtkTextDirection direction,
+                              WidgetNodeType widget) {
+  /* When the tab isn't selected, we just draw a notebook extension.
+   * When it is selected, we overwrite the adjacent border of the tabpanel
+   * touching the tab with a pierced border (called "the gap") to make the
+   * tab appear physically attached to the tabpanel; see details below. */
+
+  GtkStyleContext* style;
+  GdkRectangle tabRect;
+  GdkRectangle focusRect;
+  GdkRectangle backRect;
+  int initial_gap = 0;
+  bool isBottomTab = (widget == MOZ_GTK_TAB_BOTTOM);
+
+  style = GetStyleContext(widget, state->scale, direction,
+                          GetStateFlagsFromGtkTabFlags(flags));
+  tabRect = *rect;
+
+  if (flags & MOZ_GTK_TAB_FIRST) {
+    gtk_style_context_get_style(style, "initial-gap", &initial_gap, NULL);
+    tabRect.width -= initial_gap;
+
+    if (direction != GTK_TEXT_DIR_RTL) {
+      tabRect.x += initial_gap;
+    }
+  }
+
+  focusRect = backRect = tabRect;
+
+  if (notebook_has_tab_gap) {
+    if ((flags & MOZ_GTK_TAB_SELECTED) == 0) {
+      /* Only draw the tab */
+      gtk_render_extension(style, cr, tabRect.x, tabRect.y, tabRect.width,
+                           tabRect.height,
+                           isBottomTab ? GTK_POS_TOP : GTK_POS_BOTTOM);
+    } else {
+      /* Draw the tab and the gap
+       * We want the gap to be positioned exactly on the tabpanel top
+       * border; since tabbox.css may set a negative margin so that the tab
+       * frame rect already overlaps the tabpanel frame rect, we need to take
+       * that into account when drawing. To that effect, nsNativeThemeGTK
+       * passes us this negative margin (bmargin in the graphic below) in the
+       * lowest bits of |flags|.  We use it to set gap_voffset, the distance
+       * between the top of the gap and the bottom of the tab (resp. the
+       * bottom of the gap and the top of the tab when we draw a bottom tab),
+       * while ensuring that the gap always touches the border of the tab,
+       * i.e. 0 <= gap_voffset <= gap_height, to avoid surprinsing results
+       * with big negative or positive margins.
+       * Here is a graphical explanation in the case of top tabs:
+       *             ___________________________
+       *            /                           \
+       *           |            T A B            |
+       * ----------|. . . . . . . . . . . . . . .|----- top of tabpanel
+       *           :    ^       bmargin          :  ^
+       *           :    | (-negative margin,     :  |
+       *  bottom   :    v  passed in flags)      :  |       gap_height
+       *    of  -> :.............................:  |    (the size of the
+       * the tab   .       part of the gap       .  |  tabpanel top border)
+       *           .      outside of the tab     .  v
+       * ----------------------------------------------
+       *
+       * To draw the gap, we use gtk_render_frame_gap(), see comment in
+       * moz_gtk_tabpanels_paint(). This gap is made 3 * gap_height tall,
+       * which should suffice to ensure that the only visible border is the
+       * pierced one.  If the tab is in the middle, we make the box_gap begin
+       * a bit to the left of the tab and end a bit to the right, adjusting
+       * the gap position so it still is under the tab, because we want the
+       * rendering of a gap in the middle of a tabpanel.  This is the role of
+       * the gints gap_{l,r}_offset. On the contrary, if the tab is the
+       * first, we align the start border of the box_gap with the start
+       * border of the tab (left if LTR, right if RTL), by setting the
+       * appropriate offset to 0.*/
+      gint gap_loffset, gap_roffset, gap_voffset, gap_height;
+
+      /* Get height needed by the gap */
+      gap_height = moz_gtk_get_tab_thickness(style);
+
+      /* Extract gap_voffset from the first bits of flags */
+      gap_voffset = flags & MOZ_GTK_TAB_MARGIN_MASK;
+      if (gap_voffset > gap_height) gap_voffset = gap_height;
+
+      /* Set gap_{l,r}_offset to appropriate values */
+      gap_loffset = gap_roffset = 20; /* should be enough */
+      if (flags & MOZ_GTK_TAB_FIRST) {
+        if (direction == GTK_TEXT_DIR_RTL)
+          gap_roffset = initial_gap;
+        else
+          gap_loffset = initial_gap;
+      }
+
+      GtkStyleContext* panelStyle =
+          GetStyleContext(MOZ_GTK_TABPANELS, state->scale, direction);
+
+      if (isBottomTab) {
+        /* Draw the tab on bottom */
+        focusRect.y += gap_voffset;
+        focusRect.height -= gap_voffset;
+
+        gtk_render_extension(style, cr, tabRect.x, tabRect.y + gap_voffset,
+                             tabRect.width, tabRect.height - gap_voffset,
+                             GTK_POS_TOP);
+
+        backRect.y += (gap_voffset - gap_height);
+        backRect.height = gap_height;
+
+        /* Draw the gap; erase with background color before painting in
+         * case theme does not */
+        gtk_render_background(panelStyle, cr, backRect.x, backRect.y,
+                              backRect.width, backRect.height);
+        cairo_save(cr);
+        cairo_rectangle(cr, backRect.x, backRect.y, backRect.width,
+                        backRect.height);
+        cairo_clip(cr);
+
+        gtk_render_frame_gap(panelStyle, cr, tabRect.x - gap_loffset,
+                             tabRect.y + gap_voffset - 3 * gap_height,
+                             tabRect.width + gap_loffset + gap_roffset,
+                             3 * gap_height, GTK_POS_BOTTOM, gap_loffset,
+                             gap_loffset + tabRect.width);
+        cairo_restore(cr);
+      } else {
+        /* Draw the tab on top */
+        focusRect.height -= gap_voffset;
+        gtk_render_extension(style, cr, tabRect.x, tabRect.y, tabRect.width,
+                             tabRect.height - gap_voffset, GTK_POS_BOTTOM);
+
+        backRect.y += (tabRect.height - gap_voffset);
+        backRect.height = gap_height;
+
+        /* Draw the gap; erase with background color before painting in
+         * case theme does not */
+        gtk_render_background(panelStyle, cr, backRect.x, backRect.y,
+                              backRect.width, backRect.height);
+
+        cairo_save(cr);
+        cairo_rectangle(cr, backRect.x, backRect.y, backRect.width,
+                        backRect.height);
+        cairo_clip(cr);
+
+        gtk_render_frame_gap(panelStyle, cr, tabRect.x - gap_loffset,
+                             tabRect.y + tabRect.height - gap_voffset,
+                             tabRect.width + gap_loffset + gap_roffset,
+                             3 * gap_height, GTK_POS_TOP, gap_loffset,
+                             gap_loffset + tabRect.width);
+        cairo_restore(cr);
+      }
+    }
+  } else {
+    gtk_render_background(style, cr, tabRect.x, tabRect.y, tabRect.width,
+                          tabRect.height);
+    gtk_render_frame(style, cr, tabRect.x, tabRect.y, tabRect.width,
+                     tabRect.height);
+  }
+
+  if (state->focused) {
+    /* Paint the focus ring */
+    GtkBorder padding;
+    gtk_style_context_get_padding(style, GetStateFlagsFromGtkWidgetState(state),
+                                  &padding);
+
+    focusRect.x += padding.left;
+    focusRect.width -= (padding.left + padding.right);
+    focusRect.y += padding.top;
+    focusRect.height -= (padding.top + padding.bottom);
+
+    gtk_render_focus(style, cr, focusRect.x, focusRect.y, focusRect.width,
+                     focusRect.height);
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+/* tab area*/
+static gint moz_gtk_tabpanels_paint(cairo_t* cr, GdkRectangle* rect,
+                                    GtkWidgetState* state,
+                                    GtkTextDirection direction) {
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_TABPANELS, state->scale, direction);
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  /*
+   * The gap size is not needed in moz_gtk_tabpanels_paint because
+   * the gap will be painted with the foreground tab in moz_gtk_tab_paint.
+   *
+   * However, if moz_gtk_tabpanels_paint just uses gtk_render_frame(),
+   * the theme will think that there are no tabs and may draw something
+   * different.Hence the trick of using two clip regions, and drawing the
+   * gap outside each clip region, to get the correct frame for
+   * a tabpanel with tabs.
+   */
+  /* left side */
+  cairo_save(cr);
+  cairo_rectangle(cr, rect->x, rect->y, rect->x + rect->width / 2,
+                  rect->y + rect->height);
+  cairo_clip(cr);
+  gtk_render_frame_gap(style, cr, rect->x, rect->y, rect->width, rect->height,
+                       GTK_POS_TOP, rect->width - 1, rect->width);
+  cairo_restore(cr);
+
+  /* right side */
+  cairo_save(cr);
+  cairo_rectangle(cr, rect->x + rect->width / 2, rect->y, rect->x + rect->width,
+                  rect->y + rect->height);
+  cairo_clip(cr);
+  gtk_render_frame_gap(style, cr, rect->x, rect->y, rect->width, rect->height,
+                       GTK_POS_TOP, 0, 1);
+  cairo_restore(cr);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_tab_scroll_arrow_paint(cairo_t* cr, GdkRectangle* rect,
+                                           GtkWidgetState* state,
+                                           GtkArrowType arrow_type,
+                                           GtkTextDirection direction) {
+  GtkStyleContext* style;
+  gdouble arrow_angle;
+  gint arrow_size = MIN(rect->width, rect->height);
+  gint x = rect->x + (rect->width - arrow_size) / 2;
+  gint y = rect->y + (rect->height - arrow_size) / 2;
+
+  if (direction == GTK_TEXT_DIR_RTL) {
+    arrow_type =
+        (arrow_type == GTK_ARROW_LEFT) ? GTK_ARROW_RIGHT : GTK_ARROW_LEFT;
+  }
+  switch (arrow_type) {
+    case GTK_ARROW_LEFT:
+      arrow_angle = ARROW_LEFT;
+      break;
+    case GTK_ARROW_RIGHT:
+      arrow_angle = ARROW_RIGHT;
+      break;
+    case GTK_ARROW_DOWN:
+      arrow_angle = ARROW_DOWN;
+      break;
+    default:
+      arrow_angle = ARROW_UP;
+      break;
+  }
+  if (arrow_type != GTK_ARROW_NONE) {
+    style = GetStyleContext(MOZ_GTK_TAB_SCROLLARROW, state->scale, direction,
+                            GetStateFlagsFromGtkWidgetState(state));
+    gtk_render_arrow(style, cr, arrow_angle, x, y, arrow_size);
+  }
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_menu_bar_paint(cairo_t* cr, GdkRectangle* rect,
+                                   GtkWidgetState* state,
+                                   GtkTextDirection direction) {
+  GtkStyleContext* style;
+
+  GtkWidget* widget = GetWidget(MOZ_GTK_MENUBAR);
+  gtk_widget_set_direction(widget, direction);
+
+  style = gtk_widget_get_style_context(widget);
+  gtk_style_context_save(style);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
+  StyleContextSetScale(style, state->scale);
+
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_style_context_restore(style);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_menu_popup_paint(cairo_t* cr, GdkRectangle* rect,
+                                     GtkWidgetState* state,
+                                     GtkTextDirection direction) {
+  GtkStyleContext* style;
+
+  GtkWidget* widget = GetWidget(MOZ_GTK_MENUPOPUP);
+  gtk_widget_set_direction(widget, direction);
+
+  // Draw a backing toplevel. This fixes themes that don't provide a menu
+  // background, and depend on the GtkMenu's implementation window to provide
+  // it.
+  moz_gtk_window_paint(cr, rect, direction);
+
+  style = gtk_widget_get_style_context(widget);
+  gtk_style_context_save(style);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENU);
+  StyleContextSetScale(style, state->scale);
+
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
+  gtk_style_context_restore(style);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+// See gtk_menu_item_draw() for reference.
+static gint moz_gtk_menu_separator_paint(cairo_t* cr, GdkRectangle* rect,
+                                         GtkWidgetState* state,
+                                         GtkTextDirection direction) {
+  GtkWidgetState defaultState = {0};
+  moz_gtk_menu_item_paint(MOZ_GTK_MENUSEPARATOR, cr, rect, &defaultState,
+                          direction);
+
+  if (gtk_get_minor_version() >= 20) return MOZ_GTK_SUCCESS;
+
+  GtkStyleContext* style;
+  gboolean wide_separators;
+  gint separator_height;
+  gint x, y, w;
+  GtkBorder padding;
+
+  style = GetStyleContext(MOZ_GTK_MENUSEPARATOR, state->scale, direction);
+  gtk_style_context_get_padding(style, gtk_style_context_get_state(style),
+                                &padding);
+
+  x = rect->x;
+  y = rect->y;
+  w = rect->width;
+
+  gtk_style_context_save(style);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_SEPARATOR);
+
+  gtk_style_context_get_style(style, "wide-separators", &wide_separators,
+                              "separator-height", &separator_height, NULL);
+
+  if (wide_separators) {
+    gtk_render_frame(style, cr, x + padding.left, y + padding.top,
+                     w - padding.left - padding.right, separator_height);
+  } else {
+    gtk_render_line(style, cr, x + padding.left, y + padding.top,
+                    x + w - padding.right - 1, y + padding.top);
+  }
+
+  gtk_style_context_restore(style);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+// See gtk_menu_item_draw() for reference.
+static gint moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t* cr,
+                                    GdkRectangle* rect, GtkWidgetState* state,
+                                    GtkTextDirection direction) {
+  gint x, y, w, h;
+  guint minorVersion = gtk_get_minor_version();
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+
+  // GTK versions prior to 3.8 render the background and frame only when not
+  // a separator and in hover prelight.
+  if (minorVersion < 8 && (widget == MOZ_GTK_MENUSEPARATOR ||
+                           !(state_flags & GTK_STATE_FLAG_PRELIGHT)))
+    return MOZ_GTK_SUCCESS;
+
+  GtkStyleContext* style =
+      GetStyleContext(widget, state->scale, direction, state_flags);
+
+  if (minorVersion < 6) {
+    // GTK+ 3.4 saves the style context and adds the menubar class to
+    // menubar children, but does each of these only when drawing, not
+    // during layout.
+    gtk_style_context_save(style);
+    if (widget == MOZ_GTK_MENUBARITEM) {
+      gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
+    }
+  }
+
+  x = rect->x;
+  y = rect->y;
+  w = rect->width;
+  h = rect->height;
+
+  gtk_render_background(style, cr, x, y, w, h);
+  gtk_render_frame(style, cr, x, y, w, h);
+
+  if (minorVersion < 6) {
+    gtk_style_context_restore(style);
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_menu_arrow_paint(cairo_t* cr, GdkRectangle* rect,
+                                     GtkWidgetState* state,
+                                     GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style =
+      GetStyleContext(MOZ_GTK_MENUITEM, state->scale, direction, state_flags);
+  gtk_render_arrow(style, cr,
+                   (direction == GTK_TEXT_DIR_LTR) ? ARROW_RIGHT : ARROW_LEFT,
+                   rect->x, rect->y, rect->width);
+  return MOZ_GTK_SUCCESS;
+}
+
+// For reference, see gtk_check_menu_item_size_allocate() in GTK versions after
+// 3.20 and gtk_real_check_menu_item_draw_indicator() in earlier versions.
+static gint moz_gtk_check_menu_item_paint(WidgetNodeType widgetType,
+                                          cairo_t* cr, GdkRectangle* rect,
+                                          GtkWidgetState* state,
+                                          gboolean checked,
+                                          GtkTextDirection direction) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style;
+  gint indicator_size, horizontal_padding;
+  gint x, y;
+
+  moz_gtk_menu_item_paint(MOZ_GTK_MENUITEM, cr, rect, state, direction);
+
+  if (checked) {
+    state_flags =
+        static_cast<GtkStateFlags>(state_flags | checkbox_check_state);
+  }
+
+  bool pre_3_20 = gtk_get_minor_version() < 20;
+  gint offset;
+  style = GetStyleContext(widgetType, state->scale, direction);
+  gtk_style_context_get_style(style, "indicator-size", &indicator_size,
+                              "horizontal-padding", &horizontal_padding, NULL);
+  if (pre_3_20) {
+    GtkBorder padding;
+    gtk_style_context_get_padding(style, state_flags, &padding);
+    offset = horizontal_padding + padding.left + 2;
+  } else {
+    GdkRectangle r = {0};
+    InsetByMargin(&r, style);
+    InsetByBorderPadding(&r, style);
+    offset = r.x;
+  }
+
+  bool isRadio = (widgetType == MOZ_GTK_RADIOMENUITEM);
+  WidgetNodeType indicatorType = isRadio ? MOZ_GTK_RADIOMENUITEM_INDICATOR
+                                         : MOZ_GTK_CHECKMENUITEM_INDICATOR;
+  const ToggleGTKMetrics* metrics = GetToggleMetrics(indicatorType);
+  style = GetStyleContext(indicatorType, state->scale, direction, state_flags);
+
+  if (direction == GTK_TEXT_DIR_RTL) {
+    x = rect->width - indicator_size - offset;
+  } else {
+    x = rect->x + offset;
+  }
+  y = rect->y + (rect->height - indicator_size) / 2;
+
+  gint indicator_width, indicator_height;
+  indicator_width = indicator_height = indicator_size;
+  if (!pre_3_20) {
+    gtk_render_background(style, cr, x, y, indicator_size, indicator_size);
+    gtk_render_frame(style, cr, x, y, indicator_size, indicator_size);
+    x = x + metrics->borderAndPadding.left;
+    y = y + metrics->borderAndPadding.top;
+    indicator_width = metrics->minSizeWithBorder.width -
+                      metrics->borderAndPadding.left -
+                      metrics->borderAndPadding.right;
+    indicator_height = metrics->minSizeWithBorder.height -
+                       metrics->borderAndPadding.top -
+                       metrics->borderAndPadding.bottom;
+  }
+
+  if (isRadio) {
+    gtk_render_option(style, cr, x, y, indicator_width, indicator_height);
+  } else {
+    gtk_render_check(style, cr, x, y, indicator_width, indicator_height);
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+static gint moz_gtk_header_bar_paint(WidgetNodeType widgetType, cairo_t* cr,
+                                     GdkRectangle* rect,
+                                     GtkWidgetState* state) {
+  GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+  GtkStyleContext* style =
+      GetStyleContext(widgetType, state->scale, GTK_TEXT_DIR_NONE, state_flags);
+
+  // Some themes like Elementary's style the container of the headerbar rather
+  // than the header bar itself.
+  if (HeaderBarShouldDrawContainer(widgetType)) {
+    auto containerType = widgetType == MOZ_GTK_HEADER_BAR
+                             ? MOZ_GTK_HEADERBAR_FIXED
+                             : MOZ_GTK_HEADERBAR_FIXED_MAXIMIZED;
+    style = GetStyleContext(containerType, state->scale, GTK_TEXT_DIR_NONE,
+                            state_flags);
+  }
+
+// Some themes (Adwaita for instance) draws bold dark line at
+// titlebar bottom. It does not fit well with Firefox tabs so
+// draw with some extent to make the titlebar bottom part invisible.
+#define TITLEBAR_EXTENT 4
+
+  // We don't need to draw window decoration for MOZ_GTK_HEADER_BAR_MAXIMIZED,
+  // i.e. when main window is maximized.
+  //
+  // We also don't need to draw this on Wayland, since the compositor takes care
+  // of it.
+  if (widgetType == MOZ_GTK_HEADER_BAR &&
+      !mozilla::widget::GdkIsWaylandDisplay()) {
+    GtkStyleContext* windowStyle =
+        GetStyleContext(MOZ_GTK_HEADERBAR_WINDOW, state->scale);
+    const bool solidDecorations =
+        gtk_style_context_has_class(windowStyle, "solid-csd");
+    GtkStyleContext* decorationStyle =
+        GetStyleContext(solidDecorations ? MOZ_GTK_WINDOW_DECORATION_SOLID
+                                         : MOZ_GTK_WINDOW_DECORATION,
+                        state->scale, GTK_TEXT_DIR_LTR, state_flags);
+
+    gtk_render_background(decorationStyle, cr, rect->x, rect->y, rect->width,
+                          rect->height + TITLEBAR_EXTENT);
+    gtk_render_frame(decorationStyle, cr, rect->x, rect->y, rect->width,
+                     rect->height + TITLEBAR_EXTENT);
+  }
+
+  gtk_render_background(style, cr, rect->x, rect->y, rect->width,
+                        rect->height + TITLEBAR_EXTENT);
+  gtk_render_frame(style, cr, rect->x, rect->y, rect->width,
+                   rect->height + TITLEBAR_EXTENT);
+
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_widget_border(WidgetNodeType widget, gint* left, gint* top,
+                               gint* right, gint* bottom,
+                               // NOTE: callers depend on direction being used
+                               // only for MOZ_GTK_DROPDOWN widgets.
+                               GtkTextDirection direction) {
+  GtkWidget* w;
+  GtkStyleContext* style;
+  *left = *top = *right = *bottom = 0;
+
+  switch (widget) {
+    case MOZ_GTK_BUTTON:
+    case MOZ_GTK_TOOLBAR_BUTTON: {
+      style = GetStyleContext(MOZ_GTK_BUTTON);
+
+      *left = *top = *right = *bottom = gtk_container_get_border_width(
+          GTK_CONTAINER(GetWidget(MOZ_GTK_BUTTON)));
+
+      if (widget == MOZ_GTK_TOOLBAR_BUTTON) {
+        gtk_style_context_save(style);
+        gtk_style_context_add_class(style, "image-button");
+      }
+
+      moz_gtk_add_style_padding(style, left, top, right, bottom);
+
+      if (widget == MOZ_GTK_TOOLBAR_BUTTON) gtk_style_context_restore(style);
+
+      moz_gtk_add_style_border(style, left, top, right, bottom);
+
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_ENTRY:
+    case MOZ_GTK_DROPDOWN_ENTRY: {
+      style = GetStyleContext(widget);
+
+      // XXX: Subtract 1 pixel from the padding to account for the default
+      // padding in forms.css. See bug 1187385.
+      *left = *top = *right = *bottom = -1;
+      moz_gtk_add_border_padding(style, left, top, right, bottom);
+
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_TEXT_VIEW:
+    case MOZ_GTK_TREEVIEW: {
+      style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW);
+      moz_gtk_add_style_border(style, left, top, right, bottom);
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_TREE_HEADER_CELL: {
+      /* A Tree Header in GTK is just a different styled button
+       * It must be placed in a TreeView for getting the correct style
+       * assigned.
+       * That is why the following code is the same as for MOZ_GTK_BUTTON.
+       * */
+      *left = *top = *right = *bottom = gtk_container_get_border_width(
+          GTK_CONTAINER(GetWidget(MOZ_GTK_TREE_HEADER_CELL)));
+      style = GetStyleContext(MOZ_GTK_TREE_HEADER_CELL);
+      moz_gtk_add_border_padding(style, left, top, right, bottom);
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_TREE_HEADER_SORTARROW:
+      w = GetWidget(MOZ_GTK_TREE_HEADER_SORTARROW);
+      break;
+    case MOZ_GTK_DROPDOWN_ARROW:
+      w = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON);
+      break;
+    case MOZ_GTK_DROPDOWN: {
+      /* We need to account for the arrow on the dropdown, so text
+       * doesn't come too close to the arrow, or in some cases spill
+       * into the arrow. */
+      gboolean wide_separators;
+      gint separator_width;
+      GtkRequisition arrow_req;
+      GtkBorder border;
+
+      *left = *top = *right = *bottom = gtk_container_get_border_width(
+          GTK_CONTAINER(GetWidget(MOZ_GTK_COMBOBOX_BUTTON)));
+      style = GetStyleContext(MOZ_GTK_COMBOBOX_BUTTON);
+      moz_gtk_add_border_padding(style, left, top, right, bottom);
+
+      /* If there is no separator, don't try to count its width. */
+      separator_width = 0;
+      GtkWidget* comboBoxSeparator = GetWidget(MOZ_GTK_COMBOBOX_SEPARATOR);
+      if (comboBoxSeparator) {
+        style = gtk_widget_get_style_context(comboBoxSeparator);
+        gtk_style_context_get_style(style, "wide-separators", &wide_separators,
+                                    "separator-width", &separator_width, NULL);
+
+        if (!wide_separators) {
+          gtk_style_context_get_border(
+              style, gtk_style_context_get_state(style), &border);
+          separator_width = border.left;
+        }
+      }
+
+      gtk_widget_get_preferred_size(GetWidget(MOZ_GTK_COMBOBOX_ARROW), NULL,
+                                    &arrow_req);
+      moz_gtk_sanity_preferred_size(&arrow_req);
+
+      if (direction == GTK_TEXT_DIR_RTL)
+        *left += separator_width + arrow_req.width;
+      else
+        *right += separator_width + arrow_req.width;
+
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_TABPANELS:
+      w = GetWidget(MOZ_GTK_TABPANELS);
+      break;
+    case MOZ_GTK_PROGRESSBAR:
+      w = GetWidget(MOZ_GTK_PROGRESSBAR);
+      break;
+    case MOZ_GTK_SPINBUTTON_ENTRY:
+    case MOZ_GTK_SPINBUTTON_UP:
+    case MOZ_GTK_SPINBUTTON_DOWN:
+      w = GetWidget(MOZ_GTK_SPINBUTTON);
+      break;
+    case MOZ_GTK_SCALE_HORIZONTAL:
+    case MOZ_GTK_SCALE_VERTICAL:
+      w = GetWidget(widget);
+      break;
+    case MOZ_GTK_FRAME:
+      w = GetWidget(MOZ_GTK_FRAME);
+      break;
+    case MOZ_GTK_CHECKBUTTON_CONTAINER:
+    case MOZ_GTK_RADIOBUTTON_CONTAINER: {
+      w = GetWidget(widget);
+      style = gtk_widget_get_style_context(w);
+
+      *left = *top = *right = *bottom =
+          gtk_container_get_border_width(GTK_CONTAINER(w));
+      moz_gtk_add_border_padding(style, left, top, right, bottom);
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_MENUPOPUP:
+      w = GetWidget(MOZ_GTK_MENUPOPUP);
+      break;
+    case MOZ_GTK_MENUBARITEM:
+    case MOZ_GTK_MENUITEM:
+    case MOZ_GTK_CHECKMENUITEM:
+    case MOZ_GTK_RADIOMENUITEM: {
+      // Bug 1274143 for MOZ_GTK_MENUBARITEM
+      WidgetNodeType type =
+          widget == MOZ_GTK_MENUBARITEM ? MOZ_GTK_MENUITEM : widget;
+      style = GetStyleContext(type);
+
+      if (gtk_get_minor_version() < 20) {
+        moz_gtk_add_style_padding(style, left, top, right, bottom);
+      } else {
+        moz_gtk_add_margin_border_padding(style, left, top, right, bottom);
+      }
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_TOOLTIP: {
+      // In GTK 3 there are 6 pixels of additional margin around the box.
+      // See details there:
+      // https://github.com/GNOME/gtk/blob/5ea69a136bd7e4970b3a800390e20314665aaed2/gtk/ui/gtktooltipwindow.ui#L11
+      *left = *right = *top = *bottom = 6;
+
+      // We also need to add margin/padding/borders from Tooltip content.
+      // Tooltip contains horizontal box, where icon and label is put.
+      // We ignore icon as long as we don't have support for it.
+      GtkStyleContext* boxStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX);
+      moz_gtk_add_margin_border_padding(boxStyle, left, top, right, bottom);
+
+      GtkStyleContext* labelStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL);
+      moz_gtk_add_margin_border_padding(labelStyle, left, top, right, bottom);
+
+      return MOZ_GTK_SUCCESS;
+    }
+    case MOZ_GTK_HEADER_BAR_BUTTON_BOX: {
+      style = GetStyleContext(MOZ_GTK_HEADER_BAR);
+      moz_gtk_add_border_padding(style, left, top, right, bottom);
+      *top = *bottom = 0;
+      bool leftButtonsPlacement = false;
+      GetGtkHeaderBarButtonLayout({}, &leftButtonsPlacement);
+      if (direction == GTK_TEXT_DIR_RTL) {
+        leftButtonsPlacement = !leftButtonsPlacement;
+      }
+      if (leftButtonsPlacement) {
+        *right = 0;
+      } else {
+        *left = 0;
+      }
+      return MOZ_GTK_SUCCESS;
+    }
+    /* These widgets have no borders, since they are not containers. */
+    case MOZ_GTK_CHECKBUTTON_LABEL:
+    case MOZ_GTK_RADIOBUTTON_LABEL:
+    case MOZ_GTK_SPLITTER_HORIZONTAL:
+    case MOZ_GTK_SPLITTER_VERTICAL:
+    case MOZ_GTK_CHECKBUTTON:
+    case MOZ_GTK_RADIOBUTTON:
+    case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
+    case MOZ_GTK_SCALE_THUMB_VERTICAL:
+    case MOZ_GTK_GRIPPER:
+    case MOZ_GTK_PROGRESS_CHUNK:
+    case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE:
+    case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE:
+    case MOZ_GTK_TREEVIEW_EXPANDER:
+    case MOZ_GTK_TOOLBAR_SEPARATOR:
+    case MOZ_GTK_MENUSEPARATOR:
+    case MOZ_GTK_HEADER_BAR:
+    case MOZ_GTK_HEADER_BAR_MAXIMIZED:
+    case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE:
+    /* These widgets have no borders.*/
+    case MOZ_GTK_INNER_SPIN_BUTTON:
+    case MOZ_GTK_SPINBUTTON:
+    case MOZ_GTK_WINDOW:
+    case MOZ_GTK_RESIZER:
+    case MOZ_GTK_MENUARROW:
+    case MOZ_GTK_TOOLBARBUTTON_ARROW:
+    case MOZ_GTK_TOOLBAR:
+    case MOZ_GTK_MENUBAR:
+    case MOZ_GTK_TAB_SCROLLARROW:
+      return MOZ_GTK_SUCCESS;
+    default:
+      g_warning("Unsupported widget type: %d", widget);
+      return MOZ_GTK_UNKNOWN_WIDGET;
+  }
+  /* TODO - we're still missing some widget implementations */
+  if (w) {
+    moz_gtk_add_style_border(gtk_widget_get_style_context(w), left, top, right,
+                             bottom);
+  }
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_tab_border(gint* left, gint* top, gint* right, gint* bottom,
+                            GtkTextDirection direction, GtkTabFlags flags,
+                            WidgetNodeType widget) {
+  GtkStyleContext* style = GetStyleContext(widget, 1, direction,
+                                           GetStateFlagsFromGtkTabFlags(flags));
+
+  *left = *top = *right = *bottom = 0;
+  moz_gtk_add_style_padding(style, left, top, right, bottom);
+
+  // Gtk >= 3.20 does not use those styles
+  if (gtk_check_version(3, 20, 0) != nullptr) {
+    int tab_curvature;
+
+    gtk_style_context_get_style(style, "tab-curvature", &tab_curvature, NULL);
+    *left += tab_curvature;
+    *right += tab_curvature;
+
+    if (flags & MOZ_GTK_TAB_FIRST) {
+      int initial_gap = 0;
+      gtk_style_context_get_style(style, "initial-gap", &initial_gap, NULL);
+      if (direction == GTK_TEXT_DIR_RTL)
+        *right += initial_gap;
+      else
+        *left += initial_gap;
+    }
+  } else {
+    GtkBorder margin;
+
+    gtk_style_context_get_margin(style, gtk_style_context_get_state(style),
+                                 &margin);
+    *left += margin.left;
+    *right += margin.right;
+
+    if (flags & MOZ_GTK_TAB_FIRST) {
+      style = GetStyleContext(MOZ_GTK_NOTEBOOK_HEADER, direction);
+      gtk_style_context_get_margin(style, gtk_style_context_get_state(style),
+                                   &margin);
+      *left += margin.left;
+      *right += margin.right;
+    }
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_combo_box_entry_button_size(gint* width, gint* height) {
+  /*
+   * We get the requisition of the drop down button, which includes
+   * all padding, border and focus line widths the button uses,
+   * as well as the minimum arrow size and its padding
+   * */
+  GtkRequisition requisition;
+
+  gtk_widget_get_preferred_size(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON), NULL,
+                                &requisition);
+  moz_gtk_sanity_preferred_size(&requisition);
+
+  *width = requisition.width;
+  *height = requisition.height;
+
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_tab_scroll_arrow_size(gint* width, gint* height) {
+  gint arrow_size;
+
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_TABPANELS);
+  gtk_style_context_get_style(style, "scroll-arrow-hlength", &arrow_size, NULL);
+
+  *height = *width = arrow_size;
+
+  return MOZ_GTK_SUCCESS;
+}
+
+void moz_gtk_get_arrow_size(WidgetNodeType widgetType, gint* width,
+                            gint* height) {
+  GtkWidget* widget;
+  switch (widgetType) {
+    case MOZ_GTK_DROPDOWN:
+      widget = GetWidget(MOZ_GTK_COMBOBOX_ARROW);
+      break;
+    default:
+      widget = GetWidget(MOZ_GTK_BUTTON_ARROW);
+      break;
+  }
+
+  GtkRequisition requisition;
+  gtk_widget_get_preferred_size(widget, NULL, &requisition);
+  moz_gtk_sanity_preferred_size(&requisition);
+
+  *width = requisition.width;
+  *height = requisition.height;
+}
+
+gint moz_gtk_get_toolbar_separator_width(gint* size) {
+  gboolean wide_separators;
+  gint separator_width;
+  GtkBorder border;
+
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR);
+  gtk_style_context_get_style(style, "space-size", size, "wide-separators",
+                              &wide_separators, "separator-width",
+                              &separator_width, NULL);
+  /* Just in case... */
+  gtk_style_context_get_border(style, gtk_style_context_get_state(style),
+                               &border);
+  *size = MAX(*size, (wide_separators ? separator_width : border.left));
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_expander_size(gint* size) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_EXPANDER);
+  gtk_style_context_get_style(style, "expander-size", size, NULL);
+  return MOZ_GTK_SUCCESS;
+}
+
+gint moz_gtk_get_treeview_expander_size(gint* size) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_TREEVIEW);
+  gtk_style_context_get_style(style, "expander-size", size, NULL);
+  return MOZ_GTK_SUCCESS;
+}
+
+// See gtk_menu_item_draw() for reference.
+gint moz_gtk_get_menu_separator_height(gint* size) {
+  gboolean wide_separators;
+  gint separator_height;
+  GtkBorder padding;
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUSEPARATOR);
+  gtk_style_context_get_padding(style, gtk_style_context_get_state(style),
+                                &padding);
+
+  gtk_style_context_save(style);
+  gtk_style_context_add_class(style, GTK_STYLE_CLASS_SEPARATOR);
+
+  gtk_style_context_get_style(style, "wide-separators", &wide_separators,
+                              "separator-height", &separator_height, NULL);
+
+  gtk_style_context_restore(style);
+
+  *size = padding.top + padding.bottom;
+  *size += (wide_separators) ? separator_height : 1;
+
+  return MOZ_GTK_SUCCESS;
+}
+
+void moz_gtk_get_entry_min_height(gint* min_content_height,
+                                  gint* border_padding_height) {
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_ENTRY);
+  if (!gtk_check_version(3, 20, 0)) {
+    gtk_style_context_get(style, gtk_style_context_get_state(style),
+                          "min-height", min_content_height, nullptr);
+  } else {
+    *min_content_height = 0;
+  }
+
+  GtkBorder border;
+  GtkBorder padding;
+  gtk_style_context_get_border(style, gtk_style_context_get_state(style),
+                               &border);
+  gtk_style_context_get_padding(style, gtk_style_context_get_state(style),
+                                &padding);
+
+  *border_padding_height =
+      (border.top + border.bottom + padding.top + padding.bottom);
+}
+
+void moz_gtk_get_scale_metrics(GtkOrientation orient, gint* scale_width,
+                               gint* scale_height) {
+  if (gtk_check_version(3, 20, 0) != nullptr) {
+    WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL)
+                                ? MOZ_GTK_SCALE_HORIZONTAL
+                                : MOZ_GTK_SCALE_VERTICAL;
+
+    gint thumb_length, thumb_height, trough_border;
+    moz_gtk_get_scalethumb_metrics(orient, &thumb_length, &thumb_height);
+
+    GtkStyleContext* style = GetStyleContext(widget);
+    gtk_style_context_get_style(style, "trough-border", &trough_border, NULL);
+
+    if (orient == GTK_ORIENTATION_HORIZONTAL) {
+      *scale_width = thumb_length + trough_border * 2;
+      *scale_height = thumb_height + trough_border * 2;
+    } else {
+      *scale_width = thumb_height + trough_border * 2;
+      *scale_height = thumb_length + trough_border * 2;
+    }
+  } else {
+    WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL)
+                                ? MOZ_GTK_SCALE_TROUGH_HORIZONTAL
+                                : MOZ_GTK_SCALE_TROUGH_VERTICAL;
+    moz_gtk_get_widget_min_size(GetStyleContext(widget), scale_width,
+                                scale_height);
+  }
+}
+
+gint moz_gtk_get_scalethumb_metrics(GtkOrientation orient, gint* thumb_length,
+                                    gint* thumb_height) {
+  if (gtk_check_version(3, 20, 0) != nullptr) {
+    WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL)
+                                ? MOZ_GTK_SCALE_HORIZONTAL
+                                : MOZ_GTK_SCALE_VERTICAL;
+    GtkStyleContext* style = GetStyleContext(widget);
+    gtk_style_context_get_style(style, "slider_length", thumb_length,
+                                "slider_width", thumb_height, NULL);
+  } else {
+    WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL)
+                                ? MOZ_GTK_SCALE_THUMB_HORIZONTAL
+                                : MOZ_GTK_SCALE_THUMB_VERTICAL;
+    GtkStyleContext* style = GetStyleContext(widget);
+
+    gint min_width, min_height;
+    GtkStateFlags state = gtk_style_context_get_state(style);
+    gtk_style_context_get(style, state, "min-width", &min_width, "min-height",
+                          &min_height, nullptr);
+    GtkBorder margin;
+    gtk_style_context_get_margin(style, state, &margin);
+    gint margin_width = margin.left + margin.right;
+    gint margin_height = margin.top + margin.bottom;
+
+    // Negative margin of slider element also determines its minimal size
+    // so use bigger of those two values.
+    if (min_width < -margin_width) min_width = -margin_width;
+    if (min_height < -margin_height) min_height = -margin_height;
+
+    *thumb_length = min_width;
+    *thumb_height = min_height;
+  }
+
+  return MOZ_GTK_SUCCESS;
+}
+
+const ToggleGTKMetrics* GetToggleMetrics(WidgetNodeType aWidgetType) {
+  ToggleGTKMetrics* metrics;
+
+  switch (aWidgetType) {
+    case MOZ_GTK_RADIOBUTTON:
+      metrics = &sRadioMetrics;
+      break;
+    case MOZ_GTK_CHECKBUTTON:
+      metrics = &sCheckboxMetrics;
+      break;
+    case MOZ_GTK_RADIOMENUITEM_INDICATOR:
+      metrics = &sMenuRadioMetrics;
+      break;
+    case MOZ_GTK_CHECKMENUITEM_INDICATOR:
+      metrics = &sMenuCheckboxMetrics;
+      break;
+    default:
+      MOZ_CRASH("Unsupported widget type for getting metrics");
+      return nullptr;
+  }
+
+  metrics->initialized = true;
+  if (gtk_check_version(3, 20, 0) == nullptr) {
+    GtkStyleContext* style = GetStyleContext(aWidgetType);
+    GtkStateFlags state_flags = gtk_style_context_get_state(style);
+    gtk_style_context_get(style, state_flags, "min-height",
+                          &(metrics->minSizeWithBorder.height), "min-width",
+                          &(metrics->minSizeWithBorder.width), nullptr);
+    // Fallback to indicator size if min dimensions are zero
+    if (metrics->minSizeWithBorder.height == 0 ||
+        metrics->minSizeWithBorder.width == 0) {
+      gint indicator_size;
+      gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER),
+                           "indicator_size", &indicator_size, nullptr);
+      if (metrics->minSizeWithBorder.height == 0) {
+        metrics->minSizeWithBorder.height = indicator_size;
+      }
+      if (metrics->minSizeWithBorder.width == 0) {
+        metrics->minSizeWithBorder.width = indicator_size;
+      }
+    }
+
+    GtkBorder border, padding;
+    gtk_style_context_get_border(style, state_flags, &border);
+    gtk_style_context_get_padding(style, state_flags, &padding);
+    metrics->borderAndPadding.left = border.left + padding.left;
+    metrics->borderAndPadding.right = border.right + padding.right;
+    metrics->borderAndPadding.top = border.top + padding.top;
+    metrics->borderAndPadding.bottom = border.bottom + padding.bottom;
+    metrics->minSizeWithBorder.width +=
+        metrics->borderAndPadding.left + metrics->borderAndPadding.right;
+    metrics->minSizeWithBorder.height +=
+        metrics->borderAndPadding.top + metrics->borderAndPadding.bottom;
+  } else {
+    gint indicator_size, indicator_spacing;
+    gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER),
+                         "indicator_size", &indicator_size, "indicator_spacing",
+                         &indicator_spacing, nullptr);
+    metrics->minSizeWithBorder.width = metrics->minSizeWithBorder.height =
+        indicator_size;
+  }
+  return metrics;
+}
+
+/*
+ * get_shadow_width() from gtkwindow.c is not public so we need
+ * to implement it.
+ */
+void InitWindowDecorationSize(CSDWindowDecorationSize* sWindowDecorationSize,
+                              bool aPopupWindow) {
+  bool solidDecorations = gtk_style_context_has_class(
+      GetStyleContext(MOZ_GTK_HEADERBAR_WINDOW, 1), "solid-csd");
+  // solid-csd does not use frame extents, quit now.
+  if (solidDecorations) {
+    sWindowDecorationSize->decorationSize = {0, 0, 0, 0};
+    return;
+  }
+
+  // Scale factor is applied later when decoration size is used for actual
+  // gtk windows.
+  GtkStyleContext* context = GetStyleContext(MOZ_GTK_WINDOW_DECORATION);
+
+  /* Always sum border + padding */
+  GtkBorder padding;
+  GtkStateFlags state = gtk_style_context_get_state(context);
+  gtk_style_context_get_border(context, state,
+                               &sWindowDecorationSize->decorationSize);
+  gtk_style_context_get_padding(context, state, &padding);
+  sWindowDecorationSize->decorationSize += padding;
+
+  // Available on GTK 3.20+.
+  static auto sGtkRenderBackgroundGetClip = (void (*)(
+      GtkStyleContext*, gdouble, gdouble, gdouble, gdouble,
+      GdkRectangle*))dlsym(RTLD_DEFAULT, "gtk_render_background_get_clip");
+
+  if (!sGtkRenderBackgroundGetClip) {
+    return;
+  }
+
+  GdkRectangle clip;
+  sGtkRenderBackgroundGetClip(context, 0, 0, 0, 0, &clip);
+
+  GtkBorder extents;
+  extents.top = -clip.y;
+  extents.right = clip.width + clip.x;
+  extents.bottom = clip.height + clip.y;
+  extents.left = -clip.x;
+
+  // Get shadow extents but combine with style margin; use the bigger value.
+  // Margin is used for resize grip size - it's not present on
+  // popup windows.
+  if (!aPopupWindow) {
+    GtkBorder margin;
+    gtk_style_context_get_margin(context, state, &margin);
+
+    extents.top = MAX(extents.top, margin.top);
+    extents.right = MAX(extents.right, margin.right);
+    extents.bottom = MAX(extents.bottom, margin.bottom);
+    extents.left = MAX(extents.left, margin.left);
+  }
+
+  sWindowDecorationSize->decorationSize += extents;
+}
+
+GtkBorder GetCSDDecorationSize(bool aIsPopup) {
+  auto metrics =
+      aIsPopup ? &sPopupWindowDecorationSize : &sToplevelWindowDecorationSize;
+  if (!metrics->initialized) {
+    InitWindowDecorationSize(metrics, aIsPopup);
+    metrics->initialized = true;
+  }
+  return metrics->decorationSize;
+}
+
+/* cairo_t *cr argument has to be a system-cairo. */
+gint moz_gtk_widget_paint(WidgetNodeType widget, cairo_t* cr,
+                          GdkRectangle* rect, GtkWidgetState* state, gint flags,
+                          GtkTextDirection direction) {
+  /* A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=694086
+   */
+  cairo_new_path(cr);
+
+  switch (widget) {
+    case MOZ_GTK_BUTTON:
+    case MOZ_GTK_TOOLBAR_BUTTON:
+      if (state->depressed) {
+        return moz_gtk_button_paint(cr, rect, state, (GtkReliefStyle)flags,
+                                    GetWidget(MOZ_GTK_TOGGLE_BUTTON),
+                                    direction);
+      }
+      return moz_gtk_button_paint(cr, rect, state, (GtkReliefStyle)flags,
+                                  GetWidget(MOZ_GTK_BUTTON), direction);
+    case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
+    case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE:
+      return moz_gtk_header_bar_button_paint(
+          cr, rect, state, (GtkReliefStyle)flags, widget, direction);
+    case MOZ_GTK_CHECKBUTTON:
+    case MOZ_GTK_RADIOBUTTON:
+      return moz_gtk_toggle_paint(cr, rect, state,
+                                  !!(flags & MOZ_GTK_WIDGET_CHECKED),
+                                  !!(flags & MOZ_GTK_WIDGET_INCONSISTENT),
+                                  (widget == MOZ_GTK_RADIOBUTTON), direction);
+    case MOZ_GTK_SCALE_HORIZONTAL:
+    case MOZ_GTK_SCALE_VERTICAL:
+      return moz_gtk_scale_paint(cr, rect, state, (GtkOrientation)flags,
+                                 direction);
+    case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
+    case MOZ_GTK_SCALE_THUMB_VERTICAL:
+      return moz_gtk_scale_thumb_paint(cr, rect, state, (GtkOrientation)flags,
+                                       direction);
+    case MOZ_GTK_INNER_SPIN_BUTTON:
+      return moz_gtk_inner_spin_paint(cr, rect, state, direction);
+    case MOZ_GTK_SPINBUTTON:
+      return moz_gtk_spin_paint(cr, rect, state, direction);
+    case MOZ_GTK_SPINBUTTON_UP:
+    case MOZ_GTK_SPINBUTTON_DOWN:
+      return moz_gtk_spin_updown_paint(
+          cr, rect, (widget == MOZ_GTK_SPINBUTTON_DOWN), state, direction);
+    case MOZ_GTK_SPINBUTTON_ENTRY: {
+      GtkStyleContext* style =
+          GetStyleContext(MOZ_GTK_SPINBUTTON_ENTRY, state->scale, direction,
+                          GetStateFlagsFromGtkWidgetState(state));
+      return moz_gtk_entry_paint(cr, rect, state, style, widget);
+    }
+    case MOZ_GTK_GRIPPER:
+      return moz_gtk_gripper_paint(cr, rect, state, direction);
+    case MOZ_GTK_TREEVIEW:
+      return moz_gtk_treeview_paint(cr, rect, state, direction);
+    case MOZ_GTK_TREE_HEADER_CELL:
+      return moz_gtk_tree_header_cell_paint(cr, rect, state, flags, direction);
+    case MOZ_GTK_TREE_HEADER_SORTARROW:
+      return moz_gtk_tree_header_sort_arrow_paint(
+          cr, rect, state, (GtkArrowType)flags, direction);
+    case MOZ_GTK_TREEVIEW_EXPANDER:
+      return moz_gtk_treeview_expander_paint(
+          cr, rect, state, (GtkExpanderStyle)flags, direction);
+    case MOZ_GTK_ENTRY:
+    case MOZ_GTK_DROPDOWN_ENTRY: {
+      GtkStyleContext* style =
+          GetStyleContext(widget, state->scale, direction,
+                          GetStateFlagsFromGtkWidgetState(state));
+      gint ret = moz_gtk_entry_paint(cr, rect, state, style, widget);
+      return ret;
+    }
+    case MOZ_GTK_TEXT_VIEW:
+      return moz_gtk_text_view_paint(cr, rect, state, direction);
+    case MOZ_GTK_DROPDOWN:
+      return moz_gtk_combo_box_paint(cr, rect, state, direction);
+    case MOZ_GTK_DROPDOWN_ARROW:
+      return moz_gtk_combo_box_entry_button_paint(cr, rect, state, flags,
+                                                  direction);
+    case MOZ_GTK_CHECKBUTTON_CONTAINER:
+    case MOZ_GTK_RADIOBUTTON_CONTAINER:
+      return moz_gtk_container_paint(cr, rect, state, widget, direction);
+    case MOZ_GTK_CHECKBUTTON_LABEL:
+    case MOZ_GTK_RADIOBUTTON_LABEL:
+      return moz_gtk_toggle_label_paint(
+          cr, rect, state, (widget == MOZ_GTK_RADIOBUTTON_LABEL), direction);
+    case MOZ_GTK_TOOLBAR:
+      return moz_gtk_toolbar_paint(cr, rect, state, direction);
+    case MOZ_GTK_TOOLBAR_SEPARATOR:
+      return moz_gtk_toolbar_separator_paint(cr, rect, state, direction);
+    case MOZ_GTK_TOOLTIP:
+      return moz_gtk_tooltip_paint(cr, rect, state, direction);
+    case MOZ_GTK_FRAME:
+      return moz_gtk_frame_paint(cr, rect, state, direction);
+    case MOZ_GTK_RESIZER:
+      return moz_gtk_resizer_paint(cr, rect, state, direction);
+    case MOZ_GTK_PROGRESSBAR:
+      return moz_gtk_progressbar_paint(cr, rect, state, direction);
+    case MOZ_GTK_PROGRESS_CHUNK:
+    case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE:
+    case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE:
+      return moz_gtk_progress_chunk_paint(cr, rect, state, direction, widget);
+    case MOZ_GTK_TAB_TOP:
+    case MOZ_GTK_TAB_BOTTOM:
+      return moz_gtk_tab_paint(cr, rect, state, (GtkTabFlags)flags, direction,
+                               widget);
+    case MOZ_GTK_TABPANELS:
+      return moz_gtk_tabpanels_paint(cr, rect, state, direction);
+    case MOZ_GTK_TAB_SCROLLARROW:
+      return moz_gtk_tab_scroll_arrow_paint(cr, rect, state,
+                                            (GtkArrowType)flags, direction);
+    case MOZ_GTK_MENUBAR:
+      return moz_gtk_menu_bar_paint(cr, rect, state, direction);
+    case MOZ_GTK_MENUPOPUP:
+      return moz_gtk_menu_popup_paint(cr, rect, state, direction);
+    case MOZ_GTK_MENUSEPARATOR:
+      return moz_gtk_menu_separator_paint(cr, rect, state, direction);
+    case MOZ_GTK_MENUBARITEM:
+    case MOZ_GTK_MENUITEM:
+      return moz_gtk_menu_item_paint(widget, cr, rect, state, direction);
+    case MOZ_GTK_MENUARROW:
+      return moz_gtk_menu_arrow_paint(cr, rect, state, direction);
+    case MOZ_GTK_TOOLBARBUTTON_ARROW:
+      return moz_gtk_arrow_paint(cr, rect, state, (GtkArrowType)flags,
+                                 direction);
+    case MOZ_GTK_CHECKMENUITEM:
+    case MOZ_GTK_RADIOMENUITEM:
+      return moz_gtk_check_menu_item_paint(widget, cr, rect, state,
+                                           (gboolean)flags, direction);
+    case MOZ_GTK_SPLITTER_HORIZONTAL:
+      return moz_gtk_vpaned_paint(cr, rect, state);
+    case MOZ_GTK_SPLITTER_VERTICAL:
+      return moz_gtk_hpaned_paint(cr, rect, state);
+    case MOZ_GTK_WINDOW:
+      return moz_gtk_window_paint(cr, rect, direction);
+    case MOZ_GTK_HEADER_BAR:
+    case MOZ_GTK_HEADER_BAR_MAXIMIZED:
+      return moz_gtk_header_bar_paint(widget, cr, rect, state);
+    default:
+      g_warning("Unknown widget type: %d", widget);
+  }
+
+  return MOZ_GTK_UNKNOWN_WIDGET;
+}
+
+gint moz_gtk_shutdown() {
+  /* This will destroy all of our widgets */
+  ResetWidgetCache();
+
+  return MOZ_GTK_SUCCESS;
+}
diff --git a/widget/gtk/gtkdrawing.h b/widget/gtk/gtkdrawing.h
new file mode 100644
index 0000000000..3c46972878
--- /dev/null
+++ b/widget/gtk/gtkdrawing.h
@@ -0,0 +1,585 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * gtkdrawing.h: GTK widget rendering utilities
+ *
+ * gtkdrawing provides an API for rendering GTK widgets in the
+ * current theme to a pixmap or window, without requiring an actual
+ * widget instantiation, similar to the Macintosh Appearance Manager
+ * or Windows XP's DrawThemeBackground() API.
+ */
+
+#ifndef _GTK_DRAWING_H_
+#define _GTK_DRAWING_H_
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#include <algorithm>
+#include "mozilla/Span.h"
+
+/*** type definitions ***/
+typedef struct {
+  guint8 active;
+  guint8 focused;
+  guint8 selected;
+  guint8 inHover;
+  guint8 disabled;
+  guint8 isDefault;
+  guint8 canDefault;
+  /* The depressed state is for buttons which remain active for a longer period:
+   * activated toggle buttons or buttons showing a popup menu. */
+  guint8 depressed;
+  guint8 backdrop;
+  gint32 curpos; /* curpos and maxpos are used for scrollbars */
+  gint32 maxpos;
+  gint32 scale; /* actual widget scale */
+} GtkWidgetState;
+
+/**
+ * A size in the same GTK pixel units as GtkBorder and GdkRectangle.
+ */
+struct MozGtkSize {
+  gint width;
+  gint height;
+
+  MozGtkSize& operator+=(const GtkBorder& aBorder) {
+    width += aBorder.left + aBorder.right;
+    height += aBorder.top + aBorder.bottom;
+    return *this;
+  }
+  MozGtkSize operator+(const GtkBorder& aBorder) const {
+    MozGtkSize result = *this;
+    return result += aBorder;
+  }
+  bool operator<(const MozGtkSize& aOther) const {
+    return (width < aOther.width && height <= aOther.height) ||
+           (width <= aOther.width && height < aOther.height);
+  }
+  void Include(MozGtkSize aOther) {
+    width = std::max(width, aOther.width);
+    height = std::max(height, aOther.height);
+  }
+  void Rotate() {
+    gint tmp = width;
+    width = height;
+    height = tmp;
+  }
+};
+
+typedef struct {
+  bool initialized;
+  MozGtkSize minSizeWithBorder;
+  GtkBorder borderAndPadding;
+} ToggleGTKMetrics;
+
+typedef struct {
+  MozGtkSize minSizeWithBorderMargin;
+  GtkBorder buttonMargin;
+  gint iconXPosition;
+  gint iconYPosition;
+  bool visible;
+  bool firstButton;
+  bool lastButton;
+} ToolbarButtonGTKMetrics;
+
+#define TOOLBAR_BUTTONS 3
+typedef struct {
+  bool initialized;
+  ToolbarButtonGTKMetrics button[TOOLBAR_BUTTONS];
+} ToolbarGTKMetrics;
+
+typedef struct {
+  bool initialized;
+  GtkBorder decorationSize;
+} CSDWindowDecorationSize;
+
+/** flags for tab state **/
+typedef enum {
+  /* first eight bits are used to pass a margin */
+  MOZ_GTK_TAB_MARGIN_MASK = 0xFF,
+  /* the first tab in the group */
+  MOZ_GTK_TAB_FIRST = 1 << 9,
+  /* the selected tab */
+  MOZ_GTK_TAB_SELECTED = 1 << 10
+} GtkTabFlags;
+
+/*** result/error codes ***/
+#define MOZ_GTK_SUCCESS 0
+#define MOZ_GTK_UNKNOWN_WIDGET -1
+#define MOZ_GTK_UNSAFE_THEME -2
+
+/*** checkbox/radio flags ***/
+#define MOZ_GTK_WIDGET_CHECKED 1
+#define MOZ_GTK_WIDGET_INCONSISTENT (1 << 1)
+
+/*** widget type constants ***/
+enum WidgetNodeType : int {
+  /* Paints a GtkButton. flags is a GtkReliefStyle. */
+  MOZ_GTK_BUTTON,
+  /* Paints a button with image and no text */
+  MOZ_GTK_TOOLBAR_BUTTON,
+  /* Paints a toggle button */
+  MOZ_GTK_TOGGLE_BUTTON,
+  /* Paints a button arrow */
+  MOZ_GTK_BUTTON_ARROW,
+
+  /* Paints the container part of a GtkCheckButton. */
+  MOZ_GTK_CHECKBUTTON_CONTAINER,
+  /* Paints a GtkCheckButton. flags is a boolean, 1=checked, 0=not checked. */
+  MOZ_GTK_CHECKBUTTON,
+  /* Paints the label of a GtkCheckButton (focus outline) */
+  MOZ_GTK_CHECKBUTTON_LABEL,
+
+  /* Paints the container part of a GtkRadioButton. */
+  MOZ_GTK_RADIOBUTTON_CONTAINER,
+  /* Paints a GtkRadioButton. flags is a boolean, 1=checked, 0=not checked. */
+  MOZ_GTK_RADIOBUTTON,
+  /* Paints the label of a GtkRadioButton (focus outline) */
+  MOZ_GTK_RADIOBUTTON_LABEL,
+  /* Vertical GtkScrollbar counterparts */
+  MOZ_GTK_SCROLLBAR_VERTICAL,
+  MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL,
+  MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL,
+  MOZ_GTK_SCROLLBAR_THUMB_VERTICAL,
+
+  /* Paints a GtkScale. */
+  MOZ_GTK_SCALE_HORIZONTAL,
+  MOZ_GTK_SCALE_VERTICAL,
+  /* Paints a GtkScale trough. */
+  MOZ_GTK_SCALE_CONTENTS_HORIZONTAL,
+  MOZ_GTK_SCALE_CONTENTS_VERTICAL,
+  MOZ_GTK_SCALE_TROUGH_HORIZONTAL,
+  MOZ_GTK_SCALE_TROUGH_VERTICAL,
+  /* Paints a GtkScale thumb. */
+  MOZ_GTK_SCALE_THUMB_HORIZONTAL,
+  MOZ_GTK_SCALE_THUMB_VERTICAL,
+  /* Paints a GtkSpinButton */
+  MOZ_GTK_INNER_SPIN_BUTTON,
+  MOZ_GTK_SPINBUTTON,
+  MOZ_GTK_SPINBUTTON_UP,
+  MOZ_GTK_SPINBUTTON_DOWN,
+  MOZ_GTK_SPINBUTTON_ENTRY,
+  /* Paints the gripper of a GtkHandleBox. */
+  MOZ_GTK_GRIPPER,
+  /* Paints a GtkEntry. */
+  MOZ_GTK_ENTRY,
+  /* Paints a GtkExpander. */
+  MOZ_GTK_EXPANDER,
+  /* Paints a GtkTextView or gets the style context corresponding to the
+     root node of a GtkTextView. */
+  MOZ_GTK_TEXT_VIEW,
+  /* The "text" window or node of a GtkTextView */
+  MOZ_GTK_TEXT_VIEW_TEXT,
+  /* The "selection" node of a GtkTextView.text */
+  MOZ_GTK_TEXT_VIEW_TEXT_SELECTION,
+  /* Paints a GtkOptionMenu. */
+  MOZ_GTK_DROPDOWN,
+  /* Paints a dropdown arrow (a GtkButton containing a down GtkArrow). */
+  MOZ_GTK_DROPDOWN_ARROW,
+  /* Paints an entry in an editable option menu */
+  MOZ_GTK_DROPDOWN_ENTRY,
+
+  /* Paints the background of a GtkHandleBox. */
+  MOZ_GTK_TOOLBAR,
+  /* Paints a toolbar separator */
+  MOZ_GTK_TOOLBAR_SEPARATOR,
+  /* Paints a GtkToolTip */
+  MOZ_GTK_TOOLTIP,
+  /* Paints a GtkBox from GtkToolTip  */
+  MOZ_GTK_TOOLTIP_BOX,
+  /* Paints a GtkLabel of GtkToolTip */
+  MOZ_GTK_TOOLTIP_BOX_LABEL,
+  /* Paints a GtkFrame (e.g. a status bar panel). */
+  MOZ_GTK_FRAME,
+  /* Paints the border of a GtkFrame */
+  MOZ_GTK_FRAME_BORDER,
+  /* Paints a resize grip for a GtkTextView */
+  MOZ_GTK_RESIZER,
+  /* Paints a GtkProgressBar. */
+  MOZ_GTK_PROGRESSBAR,
+  /* Paints a trough (track) of a GtkProgressBar */
+  MOZ_GTK_PROGRESS_TROUGH,
+  /* Paints a progress chunk of a GtkProgressBar. */
+  MOZ_GTK_PROGRESS_CHUNK,
+  /* Paints a progress chunk of an indeterminated GtkProgressBar. */
+  MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE,
+  /* Paints a progress chunk of a vertical indeterminated GtkProgressBar. */
+  MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE,
+  /* Used as root style of whole GtkNotebook widget */
+  MOZ_GTK_NOTEBOOK,
+  /* Used as root style of active GtkNotebook area which contains tabs and
+     arrows. */
+  MOZ_GTK_NOTEBOOK_HEADER,
+  /* Paints a tab of a GtkNotebook. flags is a GtkTabFlags, defined above. */
+  MOZ_GTK_TAB_TOP,
+  /* Paints a tab of a GtkNotebook. flags is a GtkTabFlags, defined above. */
+  MOZ_GTK_TAB_BOTTOM,
+  /* Paints the background and border of a GtkNotebook. */
+  MOZ_GTK_TABPANELS,
+  /* Paints a GtkArrow for a GtkNotebook. flags is a GtkArrowType. */
+  MOZ_GTK_TAB_SCROLLARROW,
+  /* Paints the expander and border of a GtkTreeView */
+  MOZ_GTK_TREEVIEW,
+  /* Paints the border of a GtkTreeView */
+  MOZ_GTK_TREEVIEW_VIEW,
+  /* Paints treeheader cells */
+  MOZ_GTK_TREE_HEADER_CELL,
+  /* Paints sort arrows in treeheader cells */
+  MOZ_GTK_TREE_HEADER_SORTARROW,
+  /* Paints an expander for a GtkTreeView */
+  MOZ_GTK_TREEVIEW_EXPANDER,
+  /* Paints the background of the menu bar. */
+  MOZ_GTK_MENUBAR,
+  /* Paints the background of menus, context menus. */
+  MOZ_GTK_MENUPOPUP,
+  /* Paints the arrow of menuitems that contain submenus */
+  MOZ_GTK_MENUARROW,
+  /* Paints an arrow in a toolbar button. flags is a GtkArrowType. */
+  MOZ_GTK_TOOLBARBUTTON_ARROW,
+  /* Paints items of menubar. */
+  MOZ_GTK_MENUBARITEM,
+  /* Paints items of popup menus. */
+  MOZ_GTK_MENUITEM,
+  /* Paints a menuitem with check indicator, or the gets the style context for
+     a menuitem that contains a checkbox. */
+  MOZ_GTK_CHECKMENUITEM,
+  /* Gets the style context for a checkbox in a check menuitem. */
+  MOZ_GTK_CHECKMENUITEM_INDICATOR,
+  MOZ_GTK_RADIOMENUITEM,
+  MOZ_GTK_RADIOMENUITEM_INDICATOR,
+  MOZ_GTK_MENUSEPARATOR,
+  /* GtkVPaned base class */
+  MOZ_GTK_SPLITTER_HORIZONTAL,
+  /* GtkHPaned base class */
+  MOZ_GTK_SPLITTER_VERTICAL,
+  /* Paints a GtkVPaned separator */
+  MOZ_GTK_SPLITTER_SEPARATOR_HORIZONTAL,
+  /* Paints a GtkHPaned separator */
+  MOZ_GTK_SPLITTER_SEPARATOR_VERTICAL,
+  /* Paints the background of a window, dialog or page. */
+  MOZ_GTK_WINDOW,
+  /* Used only as a container for MOZ_GTK_HEADER_BAR. */
+  MOZ_GTK_HEADERBAR_WINDOW,
+  /* Used only as a container for MOZ_GTK_HEADER_BAR_MAXIMIZED. */
+  MOZ_GTK_HEADERBAR_WINDOW_MAXIMIZED,
+  /* Used only as a container for MOZ_GTK_HEADER_BAR. */
+  MOZ_GTK_HEADERBAR_FIXED,
+  /* Used only as a container for MOZ_GTK_HEADER_BAR_MAXIMIZED. */
+  MOZ_GTK_HEADERBAR_FIXED_MAXIMIZED,
+  /* Window container for all widgets */
+  MOZ_GTK_WINDOW_CONTAINER,
+  /* Used for widget tree construction. */
+  MOZ_GTK_COMBOBOX,
+  /* Paints a GtkComboBox button widget. */
+  MOZ_GTK_COMBOBOX_BUTTON,
+  /* Paints a GtkComboBox arrow widget. */
+  MOZ_GTK_COMBOBOX_ARROW,
+  /* Paints a GtkComboBox separator widget. */
+  MOZ_GTK_COMBOBOX_SEPARATOR,
+  /* Used for widget tree construction. */
+  MOZ_GTK_COMBOBOX_ENTRY,
+  /* Paints a GtkComboBox entry widget. */
+  MOZ_GTK_COMBOBOX_ENTRY_TEXTAREA,
+  /* Paints a GtkComboBox entry button widget. */
+  MOZ_GTK_COMBOBOX_ENTRY_BUTTON,
+  /* Paints a GtkComboBox entry arrow widget. */
+  MOZ_GTK_COMBOBOX_ENTRY_ARROW,
+  /* Used for scrolled window shell. */
+  MOZ_GTK_SCROLLED_WINDOW,
+  /* Paints a GtkHeaderBar */
+  MOZ_GTK_HEADER_BAR,
+  /* Paints a GtkHeaderBar in maximized state */
+  MOZ_GTK_HEADER_BAR_MAXIMIZED,
+  /* Container for GtkHeaderBar buttons */
+  MOZ_GTK_HEADER_BAR_BUTTON_BOX,
+  /* Paints GtkHeaderBar title buttons.
+   * Keep the order here as MOZ_GTK_HEADER_BAR_BUTTON_* are processed
+   * as an array from MOZ_GTK_HEADER_BAR_BUTTON_CLOSE to the last one.
+   */
+  MOZ_GTK_HEADER_BAR_BUTTON_CLOSE,
+  MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE,
+  MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE,
+
+  /* MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE is a state of
+   * MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE button and it's used as
+   * an icon placeholder only.
+   */
+  MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE,
+
+  /* Client-side window decoration node. Available on GTK 3.20+. */
+  MOZ_GTK_WINDOW_DECORATION,
+  MOZ_GTK_WINDOW_DECORATION_SOLID,
+
+  MOZ_GTK_MENUPOPUP_DECORATION,
+
+  MOZ_GTK_WIDGET_NODE_COUNT
+};
+
+/* ButtonLayout represents a GTK CSD button and whether its on the left or
+ * right side of the tab bar */
+struct ButtonLayout {
+  WidgetNodeType mType;
+};
+
+/*** General library functions ***/
+/**
+ * Initializes the drawing library.  You must call this function
+ * prior to using any other functionality.
+ * returns: MOZ_GTK_SUCCESS if there were no errors
+ *          MOZ_GTK_UNSAFE_THEME if the current theme engine is known
+ *                               to crash with gtkdrawing.
+ */
+gint moz_gtk_init();
+
+/**
+ * Updates the drawing library when the theme changes.
+ */
+void moz_gtk_refresh();
+
+/**
+ * Perform cleanup of the drawing library. You should call this function
+ * when your program exits, or you no longer need the library.
+ *
+ * returns: MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_shutdown();
+
+/*** Widget drawing ***/
+/**
+ * Paint a widget in the current theme.
+ * widget:    a constant giving the widget to paint
+ * drawable:  the drawable to paint to;
+ *            it's colormap must be moz_gtk_widget_get_colormap().
+ * rect:      the bounding rectangle for the widget
+ * state:     the state of the widget.  ignored for some widgets.
+ * flags:     widget-dependant flags; see the WidgetNodeType definition.
+ * direction: the text direction, to draw the widget correctly LTR and RTL.
+ */
+gint moz_gtk_widget_paint(WidgetNodeType widget, cairo_t* cr,
+                          GdkRectangle* rect, GtkWidgetState* state, gint flags,
+                          GtkTextDirection direction);
+
+/*** Widget metrics ***/
+/**
+ * Get the border size of a widget
+ * left/right:  [OUT] the widget's left/right border
+ * top/bottom:  [OUT] the widget's top/bottom border
+ * direction:   the text direction for the widget.  Callers depend on this
+ *              being used only for MOZ_GTK_DROPDOWN widgets, and cache
+ *              results for other widget types across direction values.
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_widget_border(WidgetNodeType widget, gint* left, gint* top,
+                               gint* right, gint* bottom,
+                               GtkTextDirection direction);
+
+/**
+ * Get the border size of a notebook tab
+ * left/right:  [OUT] the tab's left/right border
+ * top/bottom:  [OUT] the tab's top/bottom border
+ * direction:   the text direction for the widget
+ * flags:       tab-dependant flags; see the GtkTabFlags definition.
+ * widget:      tab widget
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_tab_border(gint* left, gint* top, gint* right, gint* bottom,
+                            GtkTextDirection direction, GtkTabFlags flags,
+                            WidgetNodeType widget);
+
+/**
+ * Get the desired size of a GtkCheckButton
+ * indicator_size:     [OUT] the indicator size
+ * indicator_spacing:  [OUT] the spacing between the indicator and its
+ *                     container
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_checkbox_get_metrics(gint* indicator_size,
+                                  gint* indicator_spacing);
+
+/**
+ * Get metrics of the toggle (radio or checkbox)
+ * isRadio:            [IN] true when requesting metrics for the radio button
+ * returns:    pointer to ToggleGTKMetrics struct
+ */
+const ToggleGTKMetrics* GetToggleMetrics(WidgetNodeType aWidgetType);
+
+/**
+ * Get the desired size of a GtkRadioButton
+ * indicator_size:     [OUT] the indicator size
+ * indicator_spacing:  [OUT] the spacing between the indicator and its
+ *                     container
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_radio_get_metrics(gint* indicator_size, gint* indicator_spacing);
+
+/** Returns the size of the focus ring for outline:auto.
+ * focus_h_width:      [OUT] the horizontal width
+ * focus_v_width:      [OUT] the vertical width
+ *
+ * returns:    MOZ_GTK_SUCCESS
+ */
+gint moz_gtk_get_focus_outline_size(gint* focus_h_width, gint* focus_v_width);
+
+/** Get the horizontal padding for the menuitem widget or checkmenuitem widget.
+ * horizontal_padding: [OUT] The left and right padding of the menuitem or
+ * checkmenuitem
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding);
+
+gint moz_gtk_checkmenuitem_get_horizontal_padding(gint* horizontal_padding);
+
+/**
+ * Some GTK themes draw their indication for the default button outside
+ * the button (e.g. the glow in New Wave). This gets the extra space necessary.
+ *
+ * border_top:  [OUT] extra space to add above
+ * border_left:  [OUT] extra space to add to the left
+ * border_bottom:  [OUT] extra space to add underneath
+ * border_right:  [OUT] extra space to add to the right
+ *
+ * returns:   MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_button_get_default_overflow(gint* border_top, gint* border_left,
+                                         gint* border_bottom,
+                                         gint* border_right);
+
+/**
+ * Gets the minimum size of a GtkScale.
+ * orient:           [IN] the scale orientation
+ * scale_width:      [OUT] the width of the scale
+ * scale_height:     [OUT] the height of the scale
+ */
+void moz_gtk_get_scale_metrics(GtkOrientation orient, gint* scale_width,
+                               gint* scale_height);
+
+/**
+ * Get the desired size of a GtkScale thumb
+ * orient:           [IN] the scale orientation
+ * thumb_length:     [OUT] the length of the thumb
+ * thumb_height:     [OUT] the height of the thumb
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_scalethumb_metrics(GtkOrientation orient, gint* thumb_length,
+                                    gint* thumb_height);
+
+/**
+ * Get the desired size of a dropdown arrow button
+ * width:   [OUT] the desired width
+ * height:  [OUT] the desired height
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_combo_box_entry_button_size(gint* width, gint* height);
+
+/**
+ * Get the desired size of a scroll arrow widget
+ * width:   [OUT] the desired width
+ * height:  [OUT] the desired height
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_tab_scroll_arrow_size(gint* width, gint* height);
+
+/**
+ * Get the desired size of an arrow in a button
+ *
+ * widgetType: [IN]  the widget for which to get the arrow size
+ * width:      [OUT] the desired width
+ * height:     [OUT] the desired height
+ */
+void moz_gtk_get_arrow_size(WidgetNodeType widgetType, gint* width,
+                            gint* height);
+
+/**
+ * Get the minimum height of a entry widget
+ * min_content_height:    [OUT] the minimum height of the content box.
+ * border_padding_height: [OUT] the size of borders and paddings.
+ */
+void moz_gtk_get_entry_min_height(gint* min_content_height,
+                                  gint* border_padding_height);
+
+/**
+ * Get the desired size of a toolbar separator
+ * size:    [OUT] the desired width
+ *
+ * returns: MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_toolbar_separator_width(gint* size);
+
+/**
+ * Get the size of a regular GTK expander that shows/hides content
+ * size:    [OUT] the size of the GTK expander, size = width = height.
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_expander_size(gint* size);
+
+/**
+ * Get the size of a treeview's expander (we call them twisties)
+ * size:    [OUT] the size of the GTK expander, size = width = height.
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_treeview_expander_size(gint* size);
+
+/**
+ * Get the desired height of a menu separator
+ * size:    [OUT] the desired height
+ *
+ * returns: MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_get_menu_separator_height(gint* size);
+
+/**
+ * Get the desired size of a splitter
+ * orientation:   [IN]  GTK_ORIENTATION_HORIZONTAL or GTK_ORIENTATION_VERTICAL
+ * size:          [OUT] width or height of the splitter handle
+ *
+ * returns:    MOZ_GTK_SUCCESS if there was no error, an error code otherwise
+ */
+gint moz_gtk_splitter_get_metrics(gint orientation, gint* size);
+
+/**
+ * Get the YTHICKNESS of a tab (notebook extension).
+ */
+gint moz_gtk_get_tab_thickness(WidgetNodeType aNodeType);
+
+/**
+ * Get ToolbarButtonGTKMetrics for recent theme.
+ */
+const ToolbarButtonGTKMetrics* GetToolbarButtonMetrics(
+    WidgetNodeType aAppearance);
+
+/**
+ * Get toolbar button layout.
+ * aButtonLayout:  [OUT] An array which will be filled by ButtonLayout
+ *                       references to visible titlebar buttons. Must contain at
+ *                       least TOOLBAR_BUTTONS entries if non-empty.
+ * aReversedButtonsPlacement: [OUT] True if the buttons are placed in opposite
+ *                                  titlebar corner.
+ *
+ * returns:    Number of returned entries at aButtonLayout.
+ */
+size_t GetGtkHeaderBarButtonLayout(mozilla::Span<ButtonLayout>,
+                                   bool* aReversedButtonsPlacement);
+
+/**
+ * Get size of CSD window extents.
+ *
+ * aIsPopup: [IN] Get decoration size for popup or toplevel window.
+ *
+ * returns: Calculated (or estimated) decoration size of given aGtkWindow.
+ */
+GtkBorder GetCSDDecorationSize(bool aIsPopup);
+
+#endif
diff --git a/widget/gtk/maiRedundantObjectFactory.c b/widget/gtk/maiRedundantObjectFactory.c
new file mode 100644
index 0000000000..ce086e20af
--- /dev/null
+++ b/widget/gtk/maiRedundantObjectFactory.c
@@ -0,0 +1,81 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <atk/atk.h>
+#include "maiRedundantObjectFactory.h"
+
+static void mai_redundant_object_factory_class_init(
+    maiRedundantObjectFactoryClass* klass);
+
+static AtkObject* mai_redundant_object_factory_create_accessible(GObject* obj);
+static GType mai_redundant_object_factory_get_accessible_type(void);
+
+GType mai_redundant_object_factory_get_type(void) {
+  static GType type = 0;
+
+  if (!type) {
+    static const GTypeInfo tinfo = {
+        sizeof(maiRedundantObjectFactoryClass),
+        (GBaseInitFunc)NULL,     /* base init */
+        (GBaseFinalizeFunc)NULL, /* base finalize */
+        (GClassInitFunc)
+            mai_redundant_object_factory_class_init, /* class init */
+        (GClassFinalizeFunc)NULL,                    /* class finalize */
+        NULL,                                        /* class data */
+        sizeof(maiRedundantObjectFactory),           /* instance size */
+        0,                                           /* nb preallocs */
+        (GInstanceInitFunc)NULL,                     /* instance init */
+        NULL                                         /* value table */
+    };
+    type = g_type_register_static(ATK_TYPE_OBJECT_FACTORY,
+                                  "MaiRedundantObjectFactory", &tinfo, 0);
+  }
+
+  return type;
+}
+
+static void mai_redundant_object_factory_class_init(
+    maiRedundantObjectFactoryClass* klass) {
+  AtkObjectFactoryClass* class = ATK_OBJECT_FACTORY_CLASS(klass);
+
+  class->create_accessible = mai_redundant_object_factory_create_accessible;
+  class->get_accessible_type = mai_redundant_object_factory_get_accessible_type;
+}
+
+/**
+ * mai_redundant_object_factory_new:
+ *
+ * Creates an instance of an #AtkObjectFactory which generates primitive
+ * (non-functioning) #AtkObjects.
+ *
+ * Returns: an instance of an #AtkObjectFactory
+ **/
+AtkObjectFactory* mai_redundant_object_factory_new() {
+  GObject* factory;
+
+  factory = g_object_new(mai_redundant_object_factory_get_type(), NULL);
+
+  g_return_val_if_fail(factory != NULL, NULL);
+  return ATK_OBJECT_FACTORY(factory);
+}
+
+static AtkObject* mai_redundant_object_factory_create_accessible(GObject* obj) {
+  AtkObject* accessible;
+
+  g_return_val_if_fail(obj != NULL, NULL);
+
+  accessible = g_object_new(ATK_TYPE_OBJECT, NULL);
+  g_return_val_if_fail(accessible != NULL, NULL);
+
+  accessible->role = ATK_ROLE_REDUNDANT_OBJECT;
+
+  return accessible;
+}
+
+static GType mai_redundant_object_factory_get_accessible_type() {
+  return mai_redundant_object_factory_get_type();
+}
diff --git a/widget/gtk/maiRedundantObjectFactory.h b/widget/gtk/maiRedundantObjectFactory.h
new file mode 100644
index 0000000000..2e6d2f572c
--- /dev/null
+++ b/widget/gtk/maiRedundantObjectFactory.h
@@ -0,0 +1,33 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __MAI_REDUNDANT_OBJECT_FACTORY_H__
+#define __MAI_REDUNDANT_OBJECT_FACTORY_H__
+
+#include <atk/atk.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef struct _maiRedundantObjectFactory maiRedundantObjectFactory;
+typedef struct _maiRedundantObjectFactoryClass maiRedundantObjectFactoryClass;
+
+struct _maiRedundantObjectFactory {
+  AtkObjectFactory parent;
+};
+
+struct _maiRedundantObjectFactoryClass {
+  AtkObjectFactoryClass parent_class;
+};
+
+GType mai_redundant_object_factory_get_type();
+
+AtkObjectFactory* mai_redundant_object_factory_new();
+
+G_END_DECLS
+
+#endif /* __NS_MAI_REDUNDANT_OBJECT_FACTORY_H__ */
diff --git a/widget/gtk/moz.build b/widget/gtk/moz.build
new file mode 100644
index 0000000000..ab248309f2
--- /dev/null
+++ b/widget/gtk/moz.build
@@ -0,0 +1,184 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Widget: Gtk")
+
+with Files("*CompositorWidget*"):
+    BUG_COMPONENT = ("Core", "Graphics")
+
+with Files("*WindowSurface*"):
+    BUG_COMPONENT = ("Core", "Graphics")
+
+with Files("*IMContextWrapper*"):
+    BUG_COMPONENT = ("Core", "DOM: UI Events & Focus Handling")
+
+with Files("*nsGtkKeyUtils*"):
+    BUG_COMPONENT = ("Core", "DOM: UI Events & Focus Handling")
+
+if CONFIG["COMPILE_ENVIRONMENT"]:
+    DIRS += ["mozgtk"]
+
+if CONFIG["MOZ_WAYLAND"]:
+    DIRS += ["wayland", "mozwayland"]
+
+EXPORTS += [
+    "MozContainer.h",
+    "nsGTKToolkit.h",
+    "nsGtkUtils.h",
+    "nsImageToPixbuf.h",
+]
+
+EXPORTS.mozilla += [
+    "GRefPtr.h",
+    "GUniquePtr.h",
+    "WidgetUtilsGtk.h",
+]
+
+EXPORTS.mozilla.widget += [
+    "WindowSurface.h",
+    "WindowSurfaceProvider.h",
+]
+
+UNIFIED_SOURCES += [
+    "AsyncGtkClipboardRequest.cpp",
+    "GfxInfo.cpp",
+    "gtk3drawing.cpp",
+    "GtkCompositorWidget.cpp",
+    "IMContextWrapper.cpp",
+    "MozContainer.cpp",
+    "MPRISServiceHandler.cpp",
+    "NativeKeyBindings.cpp",
+    "NativeMenuGtk.cpp",
+    "NativeMenuSupport.cpp",
+    "nsApplicationChooser.cpp",
+    "nsAppShell.cpp",
+    "nsBidiKeyboard.cpp",
+    "nsClipboard.cpp",
+    "nsColorPicker.cpp",
+    "nsDragService.cpp",
+    "nsFilePicker.cpp",
+    "nsGtkKeyUtils.cpp",
+    "nsImageToPixbuf.cpp",
+    "nsLookAndFeel.cpp",
+    "nsSound.cpp",
+    "nsToolkit.cpp",
+    "nsWidgetFactory.cpp",
+    "ScreenHelperGTK.cpp",
+    "TaskbarProgress.cpp",
+    "WakeLockListener.cpp",
+    "WidgetStyleCache.cpp",
+    "WidgetTraceEvent.cpp",
+    "WidgetUtilsGtk.cpp",
+    "WindowSurfaceProvider.cpp",
+]
+
+SOURCES += [
+    "MediaKeysEventSourceFactory.cpp",
+    "nsNativeThemeGTK.cpp",  # conflicts with X11 headers
+    "nsWindow.cpp",  # conflicts with X11 headers
+    "WaylandVsyncSource.cpp",  # conflicts with X11 headers
+]
+
+if CONFIG["ACCESSIBILITY"]:
+    UNIFIED_SOURCES += [
+        "maiRedundantObjectFactory.c",
+    ]
+
+if CONFIG["MOZ_WAYLAND"]:
+    UNIFIED_SOURCES += [
+        "DMABufLibWrapper.cpp",
+        "DMABufSurface.cpp",
+        "MozContainerWayland.cpp",
+        "nsClipboardWayland.cpp",
+        "nsWaylandDisplay.cpp",
+        "WaylandBuffer.cpp",
+        "WindowSurfaceWaylandMultiBuffer.cpp",
+    ]
+    EXPORTS.mozilla.widget += [
+        "DMABufLibWrapper.h",
+        "DMABufSurface.h",
+        "MozContainerWayland.h",
+        "nsWaylandDisplay.h",
+        "WaylandBuffer.h",
+    ]
+
+if CONFIG["MOZ_X11"] or CONFIG["MOZ_WAYLAND"]:
+    UNIFIED_SOURCES += [
+        "CompositorWidgetChild.cpp",
+        "CompositorWidgetParent.cpp",
+        "InProcessGtkCompositorWidget.cpp",
+        "nsUserIdleServiceGTK.cpp",
+    ]
+    EXPORTS.mozilla.widget += [
+        "CompositorWidgetChild.h",
+        "CompositorWidgetParent.h",
+        "GtkCompositorWidget.h",
+        "InProcessGtkCompositorWidget.h",
+    ]
+
+if CONFIG["MOZ_X11"]:
+    UNIFIED_SOURCES += [
+        "nsClipboardX11.cpp",
+        "nsShmImage.cpp",
+        "WindowSurfaceX11.cpp",
+        "WindowSurfaceX11Image.cpp",
+        "WindowSurfaceX11SHM.cpp",
+    ]
+
+if CONFIG["NS_PRINTING"]:
+    UNIFIED_SOURCES += [
+        "nsDeviceContextSpecG.cpp",
+        "nsPrintDialogGTK.cpp",
+        "nsPrintSettingsGTK.cpp",
+        "nsPrintSettingsServiceGTK.cpp",
+    ]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
+
+LOCAL_INCLUDES += [
+    "/layout/base",
+    "/layout/forms",
+    "/layout/generic",
+    "/layout/xul",
+    "/other-licenses/atk-1.0",
+    "/third_party/cups/include",
+    "/widget",
+    "/widget/headless",
+]
+
+if CONFIG["MOZ_X11"] or CONFIG["MOZ_WAYLAND"]:
+    LOCAL_INCLUDES += [
+        "/widget/x11",
+    ]
+
+DEFINES["CAIRO_GFX"] = True
+
+DEFINES["MOZ_APP_NAME"] = '"%s"' % CONFIG["MOZ_APP_NAME"]
+
+CFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+
+if CONFIG["MOZ_WAYLAND"]:
+    CFLAGS += CONFIG["MOZ_WAYLAND_CFLAGS"]
+    CXXFLAGS += CONFIG["MOZ_WAYLAND_CFLAGS"]
+
+if CONFIG["MOZ_ENABLE_DBUS"]:
+    EXPORTS.mozilla.widget += [
+        "AsyncDBus.h",
+    ]
+    UNIFIED_SOURCES += [
+        "AsyncDBus.cpp",
+    ]
+    CXXFLAGS += CONFIG["MOZ_DBUS_GLIB_CFLAGS"]
+
+CXXFLAGS += ["-Werror=switch"]
diff --git a/widget/gtk/mozgtk/moz.build b/widget/gtk/mozgtk/moz.build
new file mode 100644
index 0000000000..d5e78d0032
--- /dev/null
+++ b/widget/gtk/mozgtk/moz.build
@@ -0,0 +1,37 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+SharedLibrary("mozgtk")
+
+SOURCES += [
+    "mozgtk.c",
+]
+
+CFLAGS += CONFIG["MOZ_X11_CFLAGS"]
+CFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+
+# If LDFLAGS contains -Wl,--as-needed or if it's the default for the toolchain,
+# we need to add -Wl,--no-as-needed before the gtk libraries, otherwise the
+# linker will drop those dependencies because no symbols are used from them.
+# But those dependencies need to be kept for things to work properly.
+# Ideally, we'd only add -Wl,--no-as-needed if necessary, but it's just simpler
+# to add it unconditionally. This library is also simple enough that forcing
+# -Wl,--as-needed after the gtk libraries is not going to make a significant
+# difference.
+if CONFIG["GCC_USE_GNU_LD"]:
+    no_as_needed = ["-Wl,--no-as-needed"]
+    as_needed = ["-Wl,--as-needed"]
+else:
+    no_as_needed = []
+    as_needed = []
+
+OS_LIBS += [f for f in CONFIG["MOZ_GTK3_LIBS"] if f.startswith("-L")]
+OS_LIBS += no_as_needed
+OS_LIBS += [
+    "gtk-3",
+    "gdk-3",
+]
+OS_LIBS += as_needed
diff --git a/widget/gtk/mozgtk/mozgtk.c b/widget/gtk/mozgtk/mozgtk.c
new file mode 100644
index 0000000000..d95746fc0b
--- /dev/null
+++ b/widget/gtk/mozgtk/mozgtk.c
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Types.h"
+
+#include <gdk/gdk.h>
+
+// Dummy call to gtk3 library to prevent the linker from removing
+// the gtk3 dependency with --as-needed.
+// see toolkit/library/moz.build for details.
+MOZ_EXPORT void mozgtk_linker_holder() { gdk_display_get_default(); }
+
+#ifdef MOZ_X11
+#  include <X11/Xlib.h>
+// Bug 1271100
+// We need to trick system Cairo into not using the XShm extension due to
+// a race condition in it that results in frequent BadAccess errors. Cairo
+// relies upon XShmQueryExtension to initially detect if XShm is available.
+// So we define our own stub that always indicates XShm not being present.
+// mozgtk loads before libXext/libcairo and so this stub will take priority.
+// Our tree usage goes through xcb and remains unaffected by this.
+//
+// This is also used to force libxul to depend on the mozgtk library. If we
+// ever can remove this workaround for system Cairo, we'll need something
+// to replace it for that purpose.
+MOZ_EXPORT Bool XShmQueryExtension(Display* aDisplay) { return False; }
+#endif
diff --git a/widget/gtk/mozwayland/moz.build b/widget/gtk/mozwayland/moz.build
new file mode 100644
index 0000000000..0df3f0f685
--- /dev/null
+++ b/widget/gtk/mozwayland/moz.build
@@ -0,0 +1,16 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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",
+]
+EXPORTS.mozilla.widget += [
+    "mozwayland.h",
+]
+
+SharedLibrary("mozwayland")
+
+CFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
diff --git a/widget/gtk/mozwayland/mozwayland.c b/widget/gtk/mozwayland/mozwayland.c
new file mode 100644
index 0000000000..ad8e949ce2
--- /dev/null
+++ b/widget/gtk/mozwayland/mozwayland.c
@@ -0,0 +1,212 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <stdlib.h>
+#include "mozilla/Types.h"
+#include <gtk/gtk.h>
+#include <gtk/gtkx.h>
+#include <gdk/gdkwayland.h>
+
+union wl_argument;
+
+/* Those strucures are just placeholders and will be replaced by
+ * real symbols from libwayland during run-time linking. We need to make
+ * them explicitly visible.
+ */
+#pragma GCC visibility push(default)
+const struct wl_interface wl_buffer_interface;
+const struct wl_interface wl_callback_interface;
+const struct wl_interface wl_data_device_interface;
+const struct wl_interface wl_data_device_manager_interface;
+const struct wl_interface wl_keyboard_interface;
+const struct wl_interface wl_pointer_interface;
+const struct wl_interface wl_region_interface;
+const struct wl_interface wl_registry_interface;
+const struct wl_interface wl_shm_interface;
+const struct wl_interface wl_shm_pool_interface;
+const struct wl_interface wl_seat_interface;
+const struct wl_interface wl_surface_interface;
+const struct wl_interface wl_subsurface_interface;
+const struct wl_interface wl_compositor_interface;
+const struct wl_interface wl_subcompositor_interface;
+const struct wl_interface wl_output_interface;
+#pragma GCC visibility pop
+
+MOZ_EXPORT void wl_event_queue_destroy(struct wl_event_queue* queue) {}
+
+MOZ_EXPORT void wl_proxy_marshal(struct wl_proxy* p, uint32_t opcode, ...) {}
+
+MOZ_EXPORT void wl_proxy_marshal_array(struct wl_proxy* p, uint32_t opcode,
+                                       union wl_argument* args) {}
+
+MOZ_EXPORT struct wl_proxy* wl_proxy_create(
+    struct wl_proxy* factory, const struct wl_interface* interface) {
+  return NULL;
+}
+
+MOZ_EXPORT void* wl_proxy_create_wrapper(void* proxy) { return NULL; }
+
+MOZ_EXPORT void wl_proxy_wrapper_destroy(void* proxy_wrapper) {}
+
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_constructor(
+    struct wl_proxy* proxy, uint32_t opcode,
+    const struct wl_interface* interface, ...) {
+  return NULL;
+}
+
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_constructor_versioned(
+    struct wl_proxy* proxy, uint32_t opcode,
+    const struct wl_interface* interface, uint32_t version, ...) {
+  return NULL;
+}
+
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_array_constructor(
+    struct wl_proxy* proxy, uint32_t opcode, union wl_argument* args,
+    const struct wl_interface* interface) {
+  return NULL;
+}
+
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_array_constructor_versioned(
+    struct wl_proxy* proxy, uint32_t opcode, union wl_argument* args,
+    const struct wl_interface* interface, uint32_t version) {
+  return NULL;
+}
+
+MOZ_EXPORT void wl_proxy_destroy(struct wl_proxy* proxy) {}
+
+MOZ_EXPORT int wl_proxy_add_listener(struct wl_proxy* proxy,
+                                     void (**implementation)(void),
+                                     void* data) {
+  return -1;
+}
+
+MOZ_EXPORT const void* wl_proxy_get_listener(struct wl_proxy* proxy) {
+  return NULL;
+}
+
+typedef int (*wl_dispatcher_func_t)(const void*, void*, uint32_t,
+                                    const struct wl_message*,
+                                    union wl_argument*);
+
+MOZ_EXPORT int wl_proxy_add_dispatcher(struct wl_proxy* proxy,
+                                       wl_dispatcher_func_t dispatcher_func,
+                                       const void* dispatcher_data,
+                                       void* data) {
+  return -1;
+}
+
+MOZ_EXPORT void wl_proxy_set_user_data(struct wl_proxy* proxy,
+                                       void* user_data) {}
+
+MOZ_EXPORT void* wl_proxy_get_user_data(struct wl_proxy* proxy) { return NULL; }
+
+MOZ_EXPORT uint32_t wl_proxy_get_version(struct wl_proxy* proxy) { return -1; }
+
+MOZ_EXPORT uint32_t wl_proxy_get_id(struct wl_proxy* proxy) { return -1; }
+
+MOZ_EXPORT const char* wl_proxy_get_class(struct wl_proxy* proxy) {
+  return NULL;
+}
+
+MOZ_EXPORT void wl_proxy_set_queue(struct wl_proxy* proxy,
+                                   struct wl_event_queue* queue) {}
+
+MOZ_EXPORT struct wl_display* wl_display_connect(const char* name) {
+  return NULL;
+}
+
+MOZ_EXPORT struct wl_display* wl_display_connect_to_fd(int fd) { return NULL; }
+
+MOZ_EXPORT void wl_display_disconnect(struct wl_display* display) {}
+
+MOZ_EXPORT int wl_display_get_fd(struct wl_display* display) { return -1; }
+
+MOZ_EXPORT int wl_display_dispatch(struct wl_display* display) { return -1; }
+
+MOZ_EXPORT int wl_display_dispatch_queue(struct wl_display* display,
+                                         struct wl_event_queue* queue) {
+  return -1;
+}
+
+MOZ_EXPORT int wl_display_dispatch_queue_pending(struct wl_display* display,
+                                                 struct wl_event_queue* queue) {
+  return -1;
+}
+
+MOZ_EXPORT int wl_display_dispatch_pending(struct wl_display* display) {
+  return -1;
+}
+
+MOZ_EXPORT int wl_display_get_error(struct wl_display* display) { return -1; }
+
+MOZ_EXPORT uint32_t wl_display_get_protocol_error(
+    struct wl_display* display, const struct wl_interface** interface,
+    uint32_t* id) {
+  return -1;
+}
+
+MOZ_EXPORT int wl_display_flush(struct wl_display* display) { return -1; }
+
+MOZ_EXPORT int wl_display_roundtrip_queue(struct wl_display* display,
+                                          struct wl_event_queue* queue) {
+  return -1;
+}
+
+MOZ_EXPORT int wl_display_roundtrip(struct wl_display* display) { return -1; }
+
+MOZ_EXPORT struct wl_event_queue* wl_display_create_queue(
+    struct wl_display* display) {
+  return NULL;
+}
+
+MOZ_EXPORT int wl_display_prepare_read_queue(struct wl_display* display,
+                                             struct wl_event_queue* queue) {
+  return -1;
+}
+
+MOZ_EXPORT int wl_display_prepare_read(struct wl_display* display) {
+  return -1;
+}
+
+MOZ_EXPORT void wl_display_cancel_read(struct wl_display* display) {}
+
+MOZ_EXPORT int wl_display_read_events(struct wl_display* display) { return -1; }
+
+MOZ_EXPORT void wl_log_set_handler_client(wl_log_func_t handler) {}
+
+MOZ_EXPORT struct wl_egl_window* wl_egl_window_create(
+    struct wl_surface* surface, int width, int height) {
+  return NULL;
+}
+
+MOZ_EXPORT void wl_egl_window_destroy(struct wl_egl_window* egl_window) {}
+
+MOZ_EXPORT void wl_egl_window_resize(struct wl_egl_window* egl_window,
+                                     int width, int height, int dx, int dy) {}
+
+MOZ_EXPORT void wl_egl_window_get_attached_size(
+    struct wl_egl_window* egl_window, int* width, int* height) {}
+
+MOZ_EXPORT void wl_list_init(struct wl_list* list) {}
+
+MOZ_EXPORT void wl_list_insert(struct wl_list* list, struct wl_list* elm) {}
+
+MOZ_EXPORT void wl_list_remove(struct wl_list* elm) {}
+
+MOZ_EXPORT int wl_list_length(const struct wl_list* list) { return -1; }
+
+MOZ_EXPORT int wl_list_empty(const struct wl_list* list) { return -1; }
+
+MOZ_EXPORT void wl_list_insert_list(struct wl_list* list,
+                                    struct wl_list* other) {}
+
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_flags(
+    struct wl_proxy* proxy, uint32_t opcode,
+    const struct wl_interface* interface, uint32_t version, uint32_t flags,
+    ...) {
+  return NULL;
+}
diff --git a/widget/gtk/mozwayland/mozwayland.h b/widget/gtk/mozwayland/mozwayland.h
new file mode 100644
index 0000000000..22f80d6315
--- /dev/null
+++ b/widget/gtk/mozwayland/mozwayland.h
@@ -0,0 +1,134 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Wayland compatibility header, it makes Firefox build with
+   wayland-1.2 and Gtk+ 3.10.
+*/
+
+#ifndef __MozWayland_h_
+#define __MozWayland_h_
+
+#include "mozilla/Types.h"
+#include <gtk/gtk.h>
+#include <gdk/gdkwayland.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MOZ_EXPORT struct wl_display* wl_display_connect(const char* name);
+MOZ_EXPORT int wl_display_roundtrip_queue(struct wl_display* display,
+                                          struct wl_event_queue* queue);
+MOZ_EXPORT uint32_t wl_proxy_get_version(struct wl_proxy* proxy);
+MOZ_EXPORT void wl_proxy_marshal(struct wl_proxy* p, uint32_t opcode, ...);
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_constructor(
+    struct wl_proxy* proxy, uint32_t opcode,
+    const struct wl_interface* interface, ...);
+MOZ_EXPORT struct wl_proxy* wl_proxy_marshal_constructor_versioned(
+    struct wl_proxy* proxy, uint32_t opcode,
+    const struct wl_interface* interface, uint32_t version, ...);
+MOZ_EXPORT void wl_proxy_destroy(struct wl_proxy* proxy);
+MOZ_EXPORT void* wl_proxy_create_wrapper(void* proxy);
+MOZ_EXPORT void wl_proxy_wrapper_destroy(void* proxy_wrapper);
+
+/* We need implement some missing functions from wayland-client-protocol.h
+ */
+#ifndef WL_DATA_DEVICE_MANAGER_DND_ACTION_ENUM
+enum wl_data_device_manager_dnd_action {
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE = 0,
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY = 1,
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE = 2,
+  WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK = 4
+};
+#endif
+
+#ifndef WL_DATA_OFFER_SET_ACTIONS
+#  define WL_DATA_OFFER_SET_ACTIONS 4
+
+struct moz_wl_data_offer_listener {
+  void (*offer)(void* data, struct wl_data_offer* wl_data_offer,
+                const char* mime_type);
+  void (*source_actions)(void* data, struct wl_data_offer* wl_data_offer,
+                         uint32_t source_actions);
+  void (*action)(void* data, struct wl_data_offer* wl_data_offer,
+                 uint32_t dnd_action);
+};
+
+static inline void wl_data_offer_set_actions(
+    struct wl_data_offer* wl_data_offer, uint32_t dnd_actions,
+    uint32_t preferred_action) {
+  wl_proxy_marshal((struct wl_proxy*)wl_data_offer, WL_DATA_OFFER_SET_ACTIONS,
+                   dnd_actions, preferred_action);
+}
+#else
+typedef struct wl_data_offer_listener moz_wl_data_offer_listener;
+#endif
+
+#ifndef WL_SUBCOMPOSITOR_GET_SUBSURFACE
+#  define WL_SUBCOMPOSITOR_GET_SUBSURFACE 1
+struct wl_subcompositor;
+
+// Emulate what mozilla header wrapper does - make the
+// wl_subcompositor_interface always visible.
+#  pragma GCC visibility push(default)
+extern const struct wl_interface wl_subsurface_interface;
+extern const struct wl_interface wl_subcompositor_interface;
+#  pragma GCC visibility pop
+
+#  define WL_SUBSURFACE_DESTROY 0
+#  define WL_SUBSURFACE_SET_POSITION 1
+#  define WL_SUBSURFACE_PLACE_ABOVE 2
+#  define WL_SUBSURFACE_PLACE_BELOW 3
+#  define WL_SUBSURFACE_SET_SYNC 4
+#  define WL_SUBSURFACE_SET_DESYNC 5
+
+static inline struct wl_subsurface* wl_subcompositor_get_subsurface(
+    struct wl_subcompositor* wl_subcompositor, struct wl_surface* surface,
+    struct wl_surface* parent) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor(
+      (struct wl_proxy*)wl_subcompositor, WL_SUBCOMPOSITOR_GET_SUBSURFACE,
+      &wl_subsurface_interface, NULL, surface, parent);
+
+  return (struct wl_subsurface*)id;
+}
+
+static inline void wl_subsurface_set_position(
+    struct wl_subsurface* wl_subsurface, int32_t x, int32_t y) {
+  wl_proxy_marshal((struct wl_proxy*)wl_subsurface, WL_SUBSURFACE_SET_POSITION,
+                   x, y);
+}
+
+static inline void wl_subsurface_set_desync(
+    struct wl_subsurface* wl_subsurface) {
+  wl_proxy_marshal((struct wl_proxy*)wl_subsurface, WL_SUBSURFACE_SET_DESYNC);
+}
+
+static inline void wl_subsurface_destroy(struct wl_subsurface* wl_subsurface) {
+  wl_proxy_marshal((struct wl_proxy*)wl_subsurface, WL_SUBSURFACE_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)wl_subsurface);
+}
+#endif
+
+#ifndef WL_SURFACE_DAMAGE_BUFFER
+#  define WL_SURFACE_DAMAGE_BUFFER 9
+
+static inline void wl_surface_damage_buffer(struct wl_surface* wl_surface,
+                                            int32_t x, int32_t y, int32_t width,
+                                            int32_t height) {
+  wl_proxy_marshal((struct wl_proxy*)wl_surface, WL_SURFACE_DAMAGE_BUFFER, x, y,
+                   width, height);
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MozWayland_h_ */
diff --git a/widget/gtk/nsAppShell.cpp b/widget/gtk/nsAppShell.cpp
new file mode 100644
index 0000000000..97a6fb58f3
--- /dev/null
+++ b/widget/gtk/nsAppShell.cpp
@@ -0,0 +1,431 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <gdk/gdk.h>
+#include "nsAppShell.h"
+#include "nsBaseAppShell.h"
+#include "nsWindow.h"
+#include "mozilla/Logging.h"
+#include "prenv.h"
+#include "mozilla/BackgroundHangMonitor.h"
+#include "mozilla/Hal.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerThreadSleep.h"
+#include "mozilla/Unused.h"
+#include "mozilla/GUniquePtr.h"
+#include "mozilla/WidgetUtils.h"
+#include "nsIPowerManagerService.h"
+#ifdef MOZ_ENABLE_DBUS
+#  include <dbus/dbus-glib-lowlevel.h>
+#  include <gio/gio.h>
+#  include "WakeLockListener.h"
+#  include "nsIObserverService.h"
+#endif
+#include "gfxPlatform.h"
+#include "nsAppRunner.h"
+#include "mozilla/XREAppData.h"
+#include "ScreenHelperGTK.h"
+#include "HeadlessScreenHelper.h"
+#include "mozilla/widget/ScreenManager.h"
+#ifdef MOZ_WAYLAND
+#  include "nsWaylandDisplay.h"
+#endif
+
+using namespace mozilla;
+using mozilla::widget::HeadlessScreenHelper;
+using mozilla::widget::ScreenHelperGTK;
+using mozilla::widget::ScreenManager;
+
+#define NOTIFY_TOKEN 0xFA
+
+LazyLogModule gWidgetLog("Widget");
+LazyLogModule gWidgetDragLog("WidgetDrag");
+LazyLogModule gWidgetWaylandLog("WidgetWayland");
+LazyLogModule gWidgetPopupLog("WidgetPopup");
+LazyLogModule gWidgetVsync("WidgetVsync");
+LazyLogModule gDmabufLog("Dmabuf");
+LazyLogModule gClipboardLog("WidgetClipboard");
+
+static GPollFunc sPollFunc;
+
+// Wrapper function to disable hang monitoring while waiting in poll().
+static gint PollWrapper(GPollFD* aUfds, guint aNfsd, gint aTimeout) {
+  if (aTimeout == 0) {
+    // When the timeout is 0, there is no wait, so no point in notifying
+    // the BackgroundHangMonitor and the profiler.
+    return (*sPollFunc)(aUfds, aNfsd, aTimeout);
+  }
+
+  mozilla::BackgroundHangMonitor().NotifyWait();
+  gint result;
+  {
+    gint timeout = aTimeout;
+    gint64 begin = 0;
+    if (aTimeout != -1) {
+      begin = g_get_monotonic_time();
+    }
+
+    AUTO_PROFILER_LABEL("PollWrapper", IDLE);
+    AUTO_PROFILER_THREAD_SLEEP;
+    do {
+      result = (*sPollFunc)(aUfds, aNfsd, timeout);
+
+      // The result will be -1 with the EINTR error if the poll was interrupted
+      // by a signal, typically the signal sent by the profiler to sample the
+      // process. We are only done waiting if we are not in that case.
+      if (result != -1 || errno != EINTR) {
+        break;
+      }
+
+      if (aTimeout != -1) {
+        // Adjust the timeout to account for the time already spent waiting.
+        gint elapsedSinceBegin = (g_get_monotonic_time() - begin) / 1000;
+        if (elapsedSinceBegin < aTimeout) {
+          timeout = aTimeout - elapsedSinceBegin;
+        } else {
+          // poll returns 0 to indicate the call timed out before any fd
+          // became ready.
+          result = 0;
+          break;
+        }
+      }
+    } while (true);
+  }
+  mozilla::BackgroundHangMonitor().NotifyActivity();
+  return result;
+}
+
+// Emit resume-events on GdkFrameClock if flush-events has not been
+// balanced by resume-events at dispose.
+// For https://bugzilla.gnome.org/show_bug.cgi?id=742636
+static decltype(GObjectClass::constructed) sRealGdkFrameClockConstructed;
+static decltype(GObjectClass::dispose) sRealGdkFrameClockDispose;
+static GQuark sPendingResumeQuark;
+
+static void OnFlushEvents(GObject* clock, gpointer) {
+  g_object_set_qdata(clock, sPendingResumeQuark, GUINT_TO_POINTER(1));
+}
+
+static void OnResumeEvents(GObject* clock, gpointer) {
+  g_object_set_qdata(clock, sPendingResumeQuark, nullptr);
+}
+
+static void WrapGdkFrameClockConstructed(GObject* object) {
+  sRealGdkFrameClockConstructed(object);
+
+  g_signal_connect(object, "flush-events", G_CALLBACK(OnFlushEvents), nullptr);
+  g_signal_connect(object, "resume-events", G_CALLBACK(OnResumeEvents),
+                   nullptr);
+}
+
+static void WrapGdkFrameClockDispose(GObject* object) {
+  if (g_object_get_qdata(object, sPendingResumeQuark)) {
+    g_signal_emit_by_name(object, "resume-events");
+  }
+
+  sRealGdkFrameClockDispose(object);
+}
+
+/*static*/
+gboolean nsAppShell::EventProcessorCallback(GIOChannel* source,
+                                            GIOCondition condition,
+                                            gpointer data) {
+  nsAppShell* self = static_cast<nsAppShell*>(data);
+
+  unsigned char c;
+  Unused << read(self->mPipeFDs[0], &c, 1);
+  NS_ASSERTION(c == (unsigned char)NOTIFY_TOKEN, "wrong token");
+
+  self->NativeEventCallback();
+  return TRUE;
+}
+
+nsAppShell::~nsAppShell() {
+#ifdef MOZ_ENABLE_DBUS
+  StopDBusListening();
+#endif
+  mozilla::hal::Shutdown();
+
+  if (mTag) g_source_remove(mTag);
+  if (mPipeFDs[0]) close(mPipeFDs[0]);
+  if (mPipeFDs[1]) close(mPipeFDs[1]);
+}
+
+#ifdef MOZ_ENABLE_DBUS
+static void SessionSleepCallback(DBusGProxy* aProxy, gboolean aSuspend,
+                                 gpointer data) {
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (!observerService) {
+    return;
+  }
+
+  if (aSuspend) {
+    // Post sleep_notification
+    observerService->NotifyObservers(nullptr, NS_WIDGET_SLEEP_OBSERVER_TOPIC,
+                                     nullptr);
+  } else {
+    // Post wake_notification
+    observerService->NotifyObservers(nullptr, NS_WIDGET_WAKE_OBSERVER_TOPIC,
+                                     nullptr);
+  }
+}
+
+static void TimedatePropertiesChangedCallback(DBusGProxy* aProxy,
+                                              char* interface,
+                                              GHashTable* aChanged,
+                                              char** aInvalidated,
+                                              gpointer aData) {
+  // dbus signals are not fine-grained enough for us to only react to timezone
+  // changes, so we need to ensure that timezone is one of the properties
+  // changed.
+  if (g_hash_table_contains(aChanged, "Timezone")) {
+    nsBaseAppShell::OnSystemTimezoneChange();
+  }
+}
+
+static DBusHandlerResult ConnectionSignalFilter(DBusConnection* aConnection,
+                                                DBusMessage* aMessage,
+                                                void* aData) {
+  if (dbus_message_is_signal(aMessage, DBUS_INTERFACE_LOCAL, "Disconnected")) {
+    auto* appShell = static_cast<nsAppShell*>(aData);
+    appShell->StopDBusListening();
+    // We do not return DBUS_HANDLER_RESULT_HANDLED here because the connection
+    // might be shared and some other filters might want to do something.
+  }
+
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+// Based on
+// https://github.com/lcp/NetworkManager/blob/240f47c892b4e935a3e92fc09eb15163d1fa28d8/src/nm-sleep-monitor-systemd.c
+// Use login1 to signal sleep and wake notifications.
+void nsAppShell::StartDBusListening() {
+  GUniquePtr<GError> error;
+  mDBusConnection = dbus_g_bus_get(DBUS_BUS_SYSTEM, getter_Transfers(error));
+  if (!mDBusConnection) {
+    NS_WARNING(nsPrintfCString("gds: Failed to open connection to bus %s\n",
+                               error->message)
+                   .get());
+    return;
+  }
+
+  DBusConnection* dbusConnection =
+      dbus_g_connection_get_connection(mDBusConnection);
+
+  // Make sure we do not exit the entire program if DBus connection gets
+  // lost.
+  dbus_connection_set_exit_on_disconnect(dbusConnection, false);
+
+  // Listening to signals the DBus connection is going to get so we will
+  // know when it is lost and we will be able to disconnect cleanly.
+  dbus_connection_add_filter(dbusConnection, ConnectionSignalFilter, this,
+                             nullptr);
+
+  mLogin1Proxy = dbus_g_proxy_new_for_name(
+      mDBusConnection, "org.freedesktop.login1", "/org/freedesktop/login1",
+      "org.freedesktop.login1.Manager");
+
+  if (!mLogin1Proxy) {
+    NS_WARNING("gds: error creating login dbus proxy\n");
+    return;
+  }
+
+  dbus_g_proxy_add_signal(mLogin1Proxy, "PrepareForSleep", G_TYPE_BOOLEAN,
+                          G_TYPE_INVALID);
+  dbus_g_proxy_connect_signal(mLogin1Proxy, "PrepareForSleep",
+                              G_CALLBACK(SessionSleepCallback), this, nullptr);
+
+  mTimedate1Proxy = dbus_g_proxy_new_for_name(
+      mDBusConnection, "org.freedesktop.timedate1",
+      "/org/freedesktop/timedate1", "org.freedesktop.DBus.Properties");
+
+  if (!mTimedate1Proxy) {
+    NS_WARNING("gds: error creating timedate dbus proxy\n");
+    return;
+  }
+
+  dbus_g_proxy_add_signal(
+      mTimedate1Proxy, "PropertiesChanged", G_TYPE_STRING,
+      dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
+      G_TYPE_STRV, G_TYPE_INVALID);
+  dbus_g_proxy_connect_signal(mTimedate1Proxy, "PropertiesChanged",
+                              G_CALLBACK(TimedatePropertiesChangedCallback),
+                              this, nullptr);
+}
+
+void nsAppShell::StopDBusListening() {
+  // If mDBusConnection isn't initialized, that means we are not really
+  // listening.
+  if (!mDBusConnection) {
+    return;
+  }
+  dbus_connection_remove_filter(
+      dbus_g_connection_get_connection(mDBusConnection), ConnectionSignalFilter,
+      this);
+
+  if (mLogin1Proxy) {
+    dbus_g_proxy_disconnect_signal(mLogin1Proxy, "PrepareForSleep",
+                                   G_CALLBACK(SessionSleepCallback), this);
+    g_object_unref(mLogin1Proxy);
+    mLogin1Proxy = nullptr;
+  }
+
+  if (mTimedate1Proxy) {
+    dbus_g_proxy_disconnect_signal(
+        mTimedate1Proxy, "PropertiesChanged",
+        G_CALLBACK(TimedatePropertiesChangedCallback), this);
+    g_object_unref(mTimedate1Proxy);
+    mTimedate1Proxy = nullptr;
+  }
+
+  dbus_g_connection_unref(mDBusConnection);
+  mDBusConnection = nullptr;
+}
+
+#endif
+
+nsresult nsAppShell::Init() {
+  mozilla::hal::Init();
+
+#ifdef MOZ_ENABLE_DBUS
+  if (XRE_IsParentProcess()) {
+    nsCOMPtr<nsIPowerManagerService> powerManagerService =
+        do_GetService(POWERMANAGERSERVICE_CONTRACTID);
+
+    if (powerManagerService) {
+      powerManagerService->AddWakeLockListener(
+          WakeLockListener::GetSingleton());
+    } else {
+      NS_WARNING(
+          "Failed to retrieve PowerManagerService, wakelocks will be broken!");
+    }
+
+    StartDBusListening();
+  }
+#endif
+
+  if (!sPollFunc) {
+    sPollFunc = g_main_context_get_poll_func(nullptr);
+    g_main_context_set_poll_func(nullptr, &PollWrapper);
+  }
+
+  if (XRE_IsParentProcess()) {
+    ScreenManager& screenManager = ScreenManager::GetSingleton();
+    if (gfxPlatform::IsHeadless()) {
+      screenManager.SetHelper(mozilla::MakeUnique<HeadlessScreenHelper>());
+    } else {
+      screenManager.SetHelper(mozilla::MakeUnique<ScreenHelperGTK>());
+    }
+
+    if (gtk_check_version(3, 16, 3) == nullptr) {
+      // Before 3.16.3, GDK cannot override classname by --class command line
+      // option when program uses gdk_set_program_class().
+      //
+      // See https://bugzilla.gnome.org/show_bug.cgi?id=747634
+      //
+      // Only bother doing this for the parent process, since it's the one
+      // creating top-level windows.
+      if (gAppData) {
+        gdk_set_program_class(gAppData->remotingName);
+      }
+    }
+  }
+
+  if (!sPendingResumeQuark &&
+      gtk_check_version(3, 14, 7) != nullptr) {  // GTK 3.0 to GTK 3.14.7.
+    // GTK 3.8 - 3.14 registered this type when creating the frame clock
+    // for the root window of the display when the display was opened.
+    GType gdkFrameClockIdleType = g_type_from_name("GdkFrameClockIdle");
+    if (gdkFrameClockIdleType) {  // not in versions prior to 3.8
+      sPendingResumeQuark = g_quark_from_string("moz-resume-is-pending");
+      auto gdk_frame_clock_idle_class =
+          G_OBJECT_CLASS(g_type_class_peek_static(gdkFrameClockIdleType));
+      auto constructed = &gdk_frame_clock_idle_class->constructed;
+      sRealGdkFrameClockConstructed = *constructed;
+      *constructed = WrapGdkFrameClockConstructed;
+      auto dispose = &gdk_frame_clock_idle_class->dispose;
+      sRealGdkFrameClockDispose = *dispose;
+      *dispose = WrapGdkFrameClockDispose;
+    }
+  }
+
+  // Workaround for bug 1209659 which is fixed by Gtk3.20
+  if (gtk_check_version(3, 20, 0) != nullptr) {
+    unsetenv("GTK_CSD");
+  }
+
+  if (PR_GetEnv("MOZ_DEBUG_PAINTS")) {
+    gdk_window_set_debug_updates(TRUE);
+  }
+
+  // Whitelist of only common, stable formats - see bugs 1197059 and 1203078
+  GSList* pixbufFormats = gdk_pixbuf_get_formats();
+  for (GSList* iter = pixbufFormats; iter; iter = iter->next) {
+    GdkPixbufFormat* format = static_cast<GdkPixbufFormat*>(iter->data);
+    gchar* name = gdk_pixbuf_format_get_name(format);
+    if (strcmp(name, "jpeg") && strcmp(name, "png") && strcmp(name, "gif") &&
+        strcmp(name, "bmp") && strcmp(name, "ico") && strcmp(name, "xpm") &&
+        strcmp(name, "svg") && strcmp(name, "webp") && strcmp(name, "avif")) {
+      gdk_pixbuf_format_set_disabled(format, TRUE);
+    }
+    g_free(name);
+  }
+  g_slist_free(pixbufFormats);
+
+  int err = pipe(mPipeFDs);
+  if (err) return NS_ERROR_OUT_OF_MEMORY;
+
+  GIOChannel* ioc;
+  GSource* source;
+
+  // make the pipe nonblocking
+
+  int flags = fcntl(mPipeFDs[0], F_GETFL, 0);
+  if (flags == -1) goto failed;
+  err = fcntl(mPipeFDs[0], F_SETFL, flags | O_NONBLOCK);
+  if (err == -1) goto failed;
+  flags = fcntl(mPipeFDs[1], F_GETFL, 0);
+  if (flags == -1) goto failed;
+  err = fcntl(mPipeFDs[1], F_SETFL, flags | O_NONBLOCK);
+  if (err == -1) goto failed;
+
+  ioc = g_io_channel_unix_new(mPipeFDs[0]);
+  source = g_io_create_watch(ioc, G_IO_IN);
+  g_io_channel_unref(ioc);
+  g_source_set_callback(source, (GSourceFunc)EventProcessorCallback, this,
+                        nullptr);
+  g_source_set_can_recurse(source, TRUE);
+  mTag = g_source_attach(source, nullptr);
+  g_source_unref(source);
+
+  return nsBaseAppShell::Init();
+failed:
+  close(mPipeFDs[0]);
+  close(mPipeFDs[1]);
+  mPipeFDs[0] = mPipeFDs[1] = 0;
+  return NS_ERROR_FAILURE;
+}
+
+void nsAppShell::ScheduleNativeEventCallback() {
+  unsigned char buf[] = {NOTIFY_TOKEN};
+  Unused << write(mPipeFDs[1], buf, 1);
+}
+
+bool nsAppShell::ProcessNextNativeEvent(bool mayWait) {
+  if (mSuspendNativeCount) {
+    return false;
+  }
+  bool didProcessEvent = g_main_context_iteration(nullptr, mayWait);
+#ifdef MOZ_WAYLAND
+  mozilla::widget::WaylandDispatchDisplays();
+#endif
+  return didProcessEvent;
+}
diff --git a/widget/gtk/nsAppShell.h b/widget/gtk/nsAppShell.h
new file mode 100644
index 0000000000..20f718d4fa
--- /dev/null
+++ b/widget/gtk/nsAppShell.h
@@ -0,0 +1,46 @@
+/* -*- 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 nsAppShell_h__
+#define nsAppShell_h__
+
+#include <glib.h>
+#include "nsBaseAppShell.h"
+#include "nsCOMPtr.h"
+#ifdef MOZ_ENABLE_DBUS
+#  include <dbus/dbus-glib.h>
+#endif
+
+class nsAppShell : public nsBaseAppShell {
+ public:
+  nsAppShell() : mTag(0) { mPipeFDs[0] = mPipeFDs[1] = 0; }
+
+  // nsBaseAppShell overrides:
+  nsresult Init();
+  virtual void ScheduleNativeEventCallback() override;
+  virtual bool ProcessNextNativeEvent(bool mayWait) override;
+#ifdef MOZ_ENABLE_DBUS
+  void StartDBusListening();
+  void StopDBusListening();
+#endif
+
+ private:
+  virtual ~nsAppShell();
+
+  static gboolean EventProcessorCallback(GIOChannel* source,
+                                         GIOCondition condition, gpointer data);
+  int mPipeFDs[2];
+  unsigned mTag;
+
+#ifdef MOZ_ENABLE_DBUS
+  DBusGConnection* mDBusConnection = nullptr;
+  DBusGProxy* mLogin1Proxy = nullptr;
+  DBusGProxy* mTimedate1Proxy = nullptr;
+#endif
+};
+
+#endif /* nsAppShell_h__ */
diff --git a/widget/gtk/nsApplicationChooser.cpp b/widget/gtk/nsApplicationChooser.cpp
new file mode 100644
index 0000000000..6752c52caf
--- /dev/null
+++ b/widget/gtk/nsApplicationChooser.cpp
@@ -0,0 +1,132 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Types.h"
+
+#include <gtk/gtk.h>
+
+#include "nsApplicationChooser.h"
+#include "WidgetUtils.h"
+#include "nsIMIMEInfo.h"
+#include "nsIWidget.h"
+#include "nsIFile.h"
+#include "nsCExternalHandlerService.h"
+#include "nsComponentManagerUtils.h"
+#include "nsGtkUtils.h"
+#include "nsPIDOMWindow.h"
+
+using namespace mozilla;
+
+NS_IMPL_ISUPPORTS(nsApplicationChooser, nsIApplicationChooser)
+
+nsApplicationChooser::nsApplicationChooser() = default;
+
+nsApplicationChooser::~nsApplicationChooser() = default;
+
+NS_IMETHODIMP
+nsApplicationChooser::Init(mozIDOMWindowProxy* aParent,
+                           const nsACString& aTitle) {
+  NS_ENSURE_TRUE(aParent, NS_ERROR_FAILURE);
+  auto* parent = nsPIDOMWindowOuter::From(aParent);
+  mParentWidget = widget::WidgetUtils::DOMWindowToWidget(parent);
+  mWindowTitle.Assign(aTitle);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsApplicationChooser::Open(const nsACString& aContentType,
+                           nsIApplicationChooserFinishedCallback* aCallback) {
+  MOZ_ASSERT(aCallback);
+  if (mCallback) {
+    NS_WARNING("Chooser is already in progress.");
+    return NS_ERROR_ALREADY_INITIALIZED;
+  }
+  mCallback = aCallback;
+  NS_ENSURE_TRUE(mParentWidget, NS_ERROR_FAILURE);
+  GtkWindow* parent_widget =
+      GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET));
+
+  GtkWidget* chooser = gtk_app_chooser_dialog_new_for_content_type(
+      parent_widget,
+      (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+      PromiseFlatCString(aContentType).get());
+  gtk_app_chooser_dialog_set_heading(GTK_APP_CHOOSER_DIALOG(chooser),
+                                     mWindowTitle.BeginReading());
+  NS_ADDREF_THIS();
+  g_signal_connect(chooser, "response", G_CALLBACK(OnResponse), this);
+  g_signal_connect(chooser, "destroy", G_CALLBACK(OnDestroy), this);
+  gtk_widget_show(chooser);
+  return NS_OK;
+}
+
+/* static */
+void nsApplicationChooser::OnResponse(GtkWidget* chooser, gint response_id,
+                                      gpointer user_data) {
+  static_cast<nsApplicationChooser*>(user_data)->Done(chooser, response_id);
+}
+
+/* static */
+void nsApplicationChooser::OnDestroy(GtkWidget* chooser, gpointer user_data) {
+  static_cast<nsApplicationChooser*>(user_data)->Done(chooser,
+                                                      GTK_RESPONSE_CANCEL);
+}
+
+void nsApplicationChooser::Done(GtkWidget* chooser, gint response) {
+  nsCOMPtr<nsILocalHandlerApp> localHandler;
+  nsresult rv;
+  switch (response) {
+    case GTK_RESPONSE_OK:
+    case GTK_RESPONSE_ACCEPT: {
+      localHandler = do_CreateInstance(NS_LOCALHANDLERAPP_CONTRACTID, &rv);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("Out of memory.");
+        break;
+      }
+      GAppInfo* app_info =
+          gtk_app_chooser_get_app_info(GTK_APP_CHOOSER(chooser));
+
+      nsCOMPtr<nsIFile> localExecutable;
+      gchar* fileWithFullPath =
+          g_find_program_in_path(g_app_info_get_executable(app_info));
+      if (!fileWithFullPath) {
+        g_object_unref(app_info);
+        NS_WARNING("Cannot find program in path.");
+        break;
+      }
+      rv = NS_NewNativeLocalFile(nsDependentCString(fileWithFullPath), false,
+                                 getter_AddRefs(localExecutable));
+      g_free(fileWithFullPath);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("Cannot create local filename.");
+        localHandler = nullptr;
+      } else {
+        localHandler->SetExecutable(localExecutable);
+        localHandler->SetName(
+            NS_ConvertUTF8toUTF16(g_app_info_get_display_name(app_info)));
+      }
+      g_object_unref(app_info);
+    }
+
+    break;
+    case GTK_RESPONSE_CANCEL:
+    case GTK_RESPONSE_CLOSE:
+    case GTK_RESPONSE_DELETE_EVENT:
+      break;
+    default:
+      NS_WARNING("Unexpected response");
+      break;
+  }
+
+  // A "response" signal won't be sent again but "destroy" will be.
+  g_signal_handlers_disconnect_by_func(chooser, FuncToGpointer(OnDestroy),
+                                       this);
+  gtk_widget_destroy(chooser);
+
+  if (mCallback) {
+    mCallback->Done(localHandler);
+    mCallback = nullptr;
+  }
+  NS_RELEASE_THIS();
+}
diff --git a/widget/gtk/nsApplicationChooser.h b/widget/gtk/nsApplicationChooser.h
new file mode 100644
index 0000000000..22f9a808c0
--- /dev/null
+++ b/widget/gtk/nsApplicationChooser.h
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsApplicationChooser_h__
+#define nsApplicationChooser_h__
+
+#include <gtk/gtk.h>
+#include "nsCOMPtr.h"
+#include "nsIApplicationChooser.h"
+#include "nsString.h"
+
+class nsIWidget;
+
+class nsApplicationChooser final : public nsIApplicationChooser {
+ public:
+  nsApplicationChooser();
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIAPPLICATIONCHOOSER
+  void Done(GtkWidget* chooser, gint response);
+
+ private:
+  ~nsApplicationChooser();
+  nsCOMPtr<nsIWidget> mParentWidget;
+  nsCString mWindowTitle;
+  nsCOMPtr<nsIApplicationChooserFinishedCallback> mCallback;
+  static void OnResponse(GtkWidget* chooser, gint response_id,
+                         gpointer user_data);
+  static void OnDestroy(GtkWidget* chooser, gpointer user_data);
+};
+#endif
diff --git a/widget/gtk/nsBidiKeyboard.cpp b/widget/gtk/nsBidiKeyboard.cpp
new file mode 100644
index 0000000000..a57235195b
--- /dev/null
+++ b/widget/gtk/nsBidiKeyboard.cpp
@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "prlink.h"
+
+#include "nsBidiKeyboard.h"
+#include "nsIWidget.h"
+#include <gtk/gtk.h>
+
+NS_IMPL_ISUPPORTS(nsBidiKeyboard, nsIBidiKeyboard)
+
+nsBidiKeyboard::nsBidiKeyboard() { Reset(); }
+
+NS_IMETHODIMP
+nsBidiKeyboard::Reset() {
+  // NB: The default keymap can be null (e.g. in xpcshell). In that case,
+  // simply assume that we don't have bidi keyboards.
+  mHaveBidiKeyboards = false;
+
+  GdkDisplay* display = gdk_display_get_default();
+  if (!display) return NS_OK;
+
+  GdkKeymap* keymap = gdk_keymap_get_for_display(display);
+  mHaveBidiKeyboards = keymap && gdk_keymap_have_bidi_layouts(keymap);
+  return NS_OK;
+}
+
+nsBidiKeyboard::~nsBidiKeyboard() = default;
+
+NS_IMETHODIMP
+nsBidiKeyboard::IsLangRTL(bool* aIsRTL) {
+  if (!mHaveBidiKeyboards) return NS_ERROR_FAILURE;
+
+  *aIsRTL = (gdk_keymap_get_direction(gdk_keymap_get_default()) ==
+             PANGO_DIRECTION_RTL);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsBidiKeyboard::GetHaveBidiKeyboards(bool* aResult) {
+  // not implemented yet
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// static
+already_AddRefed<nsIBidiKeyboard> nsIWidget::CreateBidiKeyboardInner() {
+  return do_AddRef(new nsBidiKeyboard());
+}
diff --git a/widget/gtk/nsBidiKeyboard.h b/widget/gtk/nsBidiKeyboard.h
new file mode 100644
index 0000000000..1bc1c7e0a2
--- /dev/null
+++ b/widget/gtk/nsBidiKeyboard.h
@@ -0,0 +1,25 @@
+/* -*- 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 __nsBidiKeyboard
+#define __nsBidiKeyboard
+#include "nsIBidiKeyboard.h"
+
+class nsBidiKeyboard : public nsIBidiKeyboard {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIBIDIKEYBOARD
+
+  nsBidiKeyboard();
+
+ protected:
+  virtual ~nsBidiKeyboard();
+
+  bool mHaveBidiKeyboards;
+};
+
+#endif  // __nsBidiKeyboard
diff --git a/widget/gtk/nsClipboard.cpp b/widget/gtk/nsClipboard.cpp
new file mode 100644
index 0000000000..35b1dcbf9e
--- /dev/null
+++ b/widget/gtk/nsClipboard.cpp
@@ -0,0 +1,1335 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+
+#include "nsArrayUtils.h"
+#include "nsClipboard.h"
+#if defined(MOZ_X11)
+#  include "nsClipboardX11.h"
+#endif
+#if defined(MOZ_WAYLAND)
+#  include "nsClipboardWayland.h"
+#endif
+#include "nsGtkUtils.h"
+#include "nsIURI.h"
+#include "nsIFile.h"
+#include "nsNetUtil.h"
+#include "nsContentUtils.h"
+#include "HeadlessClipboard.h"
+#include "nsSupportsPrimitives.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsPrimitiveHelpers.h"
+#include "nsImageToPixbuf.h"
+#include "nsStringStream.h"
+#include "nsIFileURL.h"
+#include "nsIObserverService.h"
+#include "mozilla/Services.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/GRefPtr.h"
+#include "mozilla/SchedulerGroup.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/TimeStamp.h"
+#include "GRefPtr.h"
+#include "WidgetUtilsGtk.h"
+
+#include "imgIContainer.h"
+
+#include <gtk/gtk.h>
+#if defined(MOZ_X11)
+#  include <gtk/gtkx.h>
+#endif
+
+#include "mozilla/Encoding.h"
+
+using namespace mozilla;
+
+// Idle timeout for receiving selection and property notify events (microsec)
+// Right now it's set to 1 sec.
+const int kClipboardTimeout = 1000000;
+
+// Defines how many event loop iterations will be done without sleep.
+// We ususally get data in first 2-3 iterations unless some large object
+// (an image for instance) is transferred through clipboard.
+const int kClipboardFastIterationNum = 3;
+
+// We add this prefix to HTML markup, so that GetHTMLCharset can correctly
+// detect the HTML as UTF-8 encoded.
+static const char kHTMLMarkupPrefix[] =
+    R"(<meta http-equiv="content-type" content="text/html; charset=utf-8">)";
+
+static const char kURIListMime[] = "text/uri-list";
+
+ClipboardTargets nsRetrievalContext::sClipboardTargets;
+ClipboardTargets nsRetrievalContext::sPrimaryTargets;
+
+// Callback when someone asks us for the data
+void clipboard_get_cb(GtkClipboard* aGtkClipboard,
+                      GtkSelectionData* aSelectionData, guint info,
+                      gpointer user_data);
+
+// Callback when someone asks us to clear a clipboard
+void clipboard_clear_cb(GtkClipboard* aGtkClipboard, gpointer user_data);
+
+static bool GetHTMLCharset(Span<const char> aData, nsCString& str);
+
+static void SetTransferableData(nsITransferable* aTransferable,
+                                const nsACString& aFlavor,
+                                const char* aClipboardData,
+                                uint32_t aClipboardDataLength) {
+  LOGCLIP("SetTransferableData MIME %s\n", PromiseFlatCString(aFlavor).get());
+  nsCOMPtr<nsISupports> wrapper;
+  nsPrimitiveHelpers::CreatePrimitiveForData(
+      aFlavor, aClipboardData, aClipboardDataLength, getter_AddRefs(wrapper));
+  aTransferable->SetTransferData(PromiseFlatCString(aFlavor).get(), wrapper);
+}
+
+ClipboardTargets ClipboardTargets::Clone() {
+  ClipboardTargets ret;
+  ret.mCount = mCount;
+  if (mCount) {
+    ret.mTargets.reset(
+        reinterpret_cast<GdkAtom*>(g_malloc(sizeof(GdkAtom) * mCount)));
+    memcpy(ret.mTargets.get(), mTargets.get(), sizeof(GdkAtom) * mCount);
+  }
+  return ret;
+}
+
+void ClipboardTargets::Set(ClipboardTargets aTargets) {
+  mCount = aTargets.mCount;
+  mTargets = std::move(aTargets.mTargets);
+}
+
+void ClipboardData::SetData(Span<const uint8_t> aData) {
+  mData = nullptr;
+  mLength = aData.Length();
+  if (mLength) {
+    mData.reset(reinterpret_cast<char*>(g_malloc(sizeof(char) * mLength)));
+    memcpy(mData.get(), aData.data(), sizeof(char) * mLength);
+  }
+}
+
+void ClipboardData::SetText(Span<const char> aData) {
+  mData = nullptr;
+  mLength = aData.Length();
+  if (mLength) {
+    mData.reset(
+        reinterpret_cast<char*>(g_malloc(sizeof(char) * (mLength + 1))));
+    memcpy(mData.get(), aData.data(), sizeof(char) * mLength);
+    mData.get()[mLength] = '\0';
+  }
+}
+
+void ClipboardData::SetTargets(ClipboardTargets aTargets) {
+  mLength = aTargets.mCount;
+  mData.reset(reinterpret_cast<char*>(aTargets.mTargets.release()));
+}
+
+ClipboardTargets ClipboardData::ExtractTargets() {
+  GUniquePtr<GdkAtom> targets(reinterpret_cast<GdkAtom*>(mData.release()));
+  uint32_t length = std::exchange(mLength, 0);
+  return ClipboardTargets{std::move(targets), length};
+}
+
+GdkAtom GetSelectionAtom(int32_t aWhichClipboard) {
+  if (aWhichClipboard == nsIClipboard::kGlobalClipboard)
+    return GDK_SELECTION_CLIPBOARD;
+
+  return GDK_SELECTION_PRIMARY;
+}
+
+int GetGeckoClipboardType(GtkClipboard* aGtkClipboard) {
+  if (aGtkClipboard == gtk_clipboard_get(GDK_SELECTION_PRIMARY))
+    return nsClipboard::kSelectionClipboard;
+  else if (aGtkClipboard == gtk_clipboard_get(GDK_SELECTION_CLIPBOARD))
+    return nsClipboard::kGlobalClipboard;
+
+  return -1;  // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
+}
+
+void nsRetrievalContext::ClearCachedTargetsClipboard(GtkClipboard* aClipboard,
+                                                     GdkEvent* aEvent,
+                                                     gpointer data) {
+  LOGCLIP("nsRetrievalContext::ClearCachedTargetsClipboard()");
+  sClipboardTargets.Clear();
+}
+
+void nsRetrievalContext::ClearCachedTargetsPrimary(GtkClipboard* aClipboard,
+                                                   GdkEvent* aEvent,
+                                                   gpointer data) {
+  LOGCLIP("nsRetrievalContext::ClearCachedTargetsPrimary()");
+  sPrimaryTargets.Clear();
+}
+
+ClipboardTargets nsRetrievalContext::GetTargets(int32_t aWhichClipboard) {
+  LOGCLIP("nsRetrievalContext::GetTargets(%s)\n",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard");
+  ClipboardTargets& storedTargets =
+      (aWhichClipboard == nsClipboard::kSelectionClipboard) ? sPrimaryTargets
+                                                            : sClipboardTargets;
+  if (!storedTargets) {
+    LOGCLIP("  getting targets from system");
+    storedTargets.Set(GetTargetsImpl(aWhichClipboard));
+  } else {
+    LOGCLIP("  using cached targets");
+  }
+  return storedTargets.Clone();
+}
+
+nsRetrievalContext::nsRetrievalContext() {
+  g_signal_connect(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), "owner-change",
+                   G_CALLBACK(ClearCachedTargetsClipboard), this);
+  g_signal_connect(gtk_clipboard_get(GDK_SELECTION_PRIMARY), "owner-change",
+                   G_CALLBACK(ClearCachedTargetsPrimary), this);
+}
+
+nsRetrievalContext::~nsRetrievalContext() {
+  g_signal_handlers_disconnect_by_func(
+      gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
+      FuncToGpointer(ClearCachedTargetsClipboard), this);
+  g_signal_handlers_disconnect_by_func(
+      gtk_clipboard_get(GDK_SELECTION_PRIMARY),
+      FuncToGpointer(ClearCachedTargetsPrimary), this);
+  sClipboardTargets.Clear();
+  sPrimaryTargets.Clear();
+}
+
+nsClipboard::nsClipboard() = default;
+
+nsClipboard::~nsClipboard() {
+  // We have to clear clipboard before gdk_display_close() call.
+  // See bug 531580 for details.
+  if (mGlobalTransferable) {
+    gtk_clipboard_clear(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
+  }
+  if (mSelectionTransferable) {
+    gtk_clipboard_clear(gtk_clipboard_get(GDK_SELECTION_PRIMARY));
+  }
+}
+
+NS_IMPL_ISUPPORTS(nsClipboard, nsIClipboard, nsIObserver)
+
+nsresult nsClipboard::Init(void) {
+#if defined(MOZ_X11)
+  if (widget::GdkIsX11Display()) {
+    mContext = new nsRetrievalContextX11();
+  }
+#endif
+#if defined(MOZ_WAYLAND)
+  if (widget::GdkIsWaylandDisplay()) {
+    mContext = new nsRetrievalContextWayland();
+  }
+#endif
+
+  nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+  if (os) {
+    os->AddObserver(this, "xpcom-shutdown", false);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsClipboard::Observe(nsISupports* aSubject, const char* aTopic,
+                     const char16_t* aData) {
+  // Save global clipboard content to CLIPBOARD_MANAGER.
+  // gtk_clipboard_store() can run an event loop, so call from a dedicated
+  // runnable.
+  return SchedulerGroup::Dispatch(
+      TaskCategory::Other,
+      NS_NewRunnableFunction("gtk_clipboard_store()", []() {
+        LOGCLIP("nsClipboard storing clipboard content\n");
+        gtk_clipboard_store(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
+      }));
+}
+
+NS_IMETHODIMP
+nsClipboard::SetData(nsITransferable* aTransferable, nsIClipboardOwner* aOwner,
+                     int32_t aWhichClipboard) {
+  // See if we can short cut
+  if ((aWhichClipboard == kGlobalClipboard &&
+       aTransferable == mGlobalTransferable.get() &&
+       aOwner == mGlobalOwner.get()) ||
+      (aWhichClipboard == kSelectionClipboard &&
+       aTransferable == mSelectionTransferable.get() &&
+       aOwner == mSelectionOwner.get())) {
+    return NS_OK;
+  }
+
+  LOGCLIP("nsClipboard::SetData (%s)\n",
+          aWhichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+
+  // List of suported targets
+  GtkTargetList* list = gtk_target_list_new(nullptr, 0);
+
+  // Get the types of supported flavors
+  nsTArray<nsCString> flavors;
+  nsresult rv = aTransferable->FlavorsTransferableCanExport(flavors);
+  if (NS_FAILED(rv)) {
+    LOGCLIP("    FlavorsTransferableCanExport failed!\n");
+    // Fall through.  |gtkTargets| will be null below.
+  }
+
+  // Add all the flavors to this widget's supported type.
+  bool imagesAdded = false;
+  for (uint32_t i = 0; i < flavors.Length(); i++) {
+    nsCString& flavorStr = flavors[i];
+    LOGCLIP("    processing target %s\n", flavorStr.get());
+
+    // Special case text/unicode since we can handle all of the string types.
+    if (flavorStr.EqualsLiteral(kUnicodeMime)) {
+      LOGCLIP("    adding TEXT targets\n");
+      gtk_target_list_add_text_targets(list, 0);
+      continue;
+    }
+
+    if (nsContentUtils::IsFlavorImage(flavorStr)) {
+      // Don't bother adding image targets twice
+      if (!imagesAdded) {
+        // accept any writable image type
+        LOGCLIP("    adding IMAGE targets\n");
+        gtk_target_list_add_image_targets(list, 0, TRUE);
+        imagesAdded = true;
+      }
+      continue;
+    }
+
+    // Add this to our list of valid targets
+    LOGCLIP("    adding OTHER target %s\n", flavorStr.get());
+    GdkAtom atom = gdk_atom_intern(flavorStr.get(), FALSE);
+    gtk_target_list_add(list, atom, 0, 0);
+  }
+
+  // Get GTK clipboard (CLIPBOARD or PRIMARY)
+  GtkClipboard* gtkClipboard =
+      gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
+
+  gint numTargets = 0;
+  GtkTargetEntry* gtkTargets =
+      gtk_target_table_new_from_list(list, &numTargets);
+  if (!gtkTargets || numTargets == 0) {
+    LOGCLIP(
+        "    gtk_target_table_new_from_list() failed or empty list of "
+        "targets!\n");
+    // Clear references to the any old data and let GTK know that it is no
+    // longer available.
+    EmptyClipboard(aWhichClipboard);
+    return NS_ERROR_FAILURE;
+  }
+
+  ClearCachedTargets(aWhichClipboard);
+
+  // Set getcallback and request to store data after an application exit
+  if (gtk_clipboard_set_with_data(gtkClipboard, gtkTargets, numTargets,
+                                  clipboard_get_cb, clipboard_clear_cb, this)) {
+    // We managed to set-up the clipboard so update internal state
+    // We have to set it now because gtk_clipboard_set_with_data() calls
+    // clipboard_clear_cb() which reset our internal state
+    if (aWhichClipboard == kSelectionClipboard) {
+      mSelectionOwner = aOwner;
+      mSelectionTransferable = aTransferable;
+    } else {
+      mGlobalOwner = aOwner;
+      mGlobalTransferable = aTransferable;
+      gtk_clipboard_set_can_store(gtkClipboard, gtkTargets, numTargets);
+    }
+
+    rv = NS_OK;
+  } else {
+    LOGCLIP("    gtk_clipboard_set_with_data() failed!\n");
+    EmptyClipboard(aWhichClipboard);
+    rv = NS_ERROR_FAILURE;
+  }
+
+  gtk_target_table_free(gtkTargets, numTargets);
+  gtk_target_list_unref(list);
+
+  return rv;
+}
+
+static bool IsMIMEAtFlavourList(const nsTArray<nsCString>& aFlavourList,
+                                const char* aMime) {
+  for (const auto& flavorStr : aFlavourList) {
+    if (flavorStr.Equals(aMime)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// When clipboard contains only images, X11/Gtk tries to convert them
+// to text when we request text instead of just fail to provide the data.
+// So if clipboard contains images only remove text MIME offer.
+bool nsClipboard::FilterImportedFlavors(int32_t aWhichClipboard,
+                                        nsTArray<nsCString>& aFlavors) {
+  LOGCLIP("nsClipboard::FilterImportedFlavors");
+
+  auto targets = mContext->GetTargets(aWhichClipboard);
+  if (!targets) {
+    LOGCLIP("    X11: no targes at clipboard (null), quit.\n");
+    return true;
+  }
+
+  for (const auto& atom : targets.AsSpan()) {
+    GUniquePtr<gchar> atom_name(gdk_atom_name(atom));
+    if (!atom_name) {
+      continue;
+    }
+    // Filter out system MIME types.
+    if (strcmp(atom_name.get(), "TARGETS") == 0 ||
+        strcmp(atom_name.get(), "TIMESTAMP") == 0 ||
+        strcmp(atom_name.get(), "SAVE_TARGETS") == 0 ||
+        strcmp(atom_name.get(), "MULTIPLE") == 0) {
+      continue;
+    }
+    // Filter out types which can't be converted to text.
+    if (strncmp(atom_name.get(), "image/", 6) == 0 ||
+        strncmp(atom_name.get(), "application/", 12) == 0 ||
+        strncmp(atom_name.get(), "audio/", 6) == 0 ||
+        strncmp(atom_name.get(), "video/", 6) == 0) {
+      continue;
+    }
+    // We have some other MIME type on clipboard which can be hopefully
+    // converted to text without any problem.
+    LOGCLIP("    X11: text types in clipboard, no need to filter them.\n");
+    return true;
+  }
+
+  // So make sure we offer only types we have at clipboard.
+  nsTArray<nsCString> clipboardFlavors;
+  for (const auto& atom : targets.AsSpan()) {
+    GUniquePtr<gchar> atom_name(gdk_atom_name(atom));
+    if (!atom_name) {
+      continue;
+    }
+    if (IsMIMEAtFlavourList(aFlavors, atom_name.get())) {
+      clipboardFlavors.AppendElement(nsCString(atom_name.get()));
+    }
+  }
+  aFlavors.SwapElements(clipboardFlavors);
+#ifdef MOZ_LOGGING
+  LOGCLIP("    X11: Flavors which match clipboard content:\n");
+  for (uint32_t i = 0; i < aFlavors.Length(); i++) {
+    LOGCLIP("    %s\n", aFlavors[i].get());
+  }
+#endif
+  return true;
+}
+
+static nsresult GetTransferableFlavors(nsITransferable* aTransferable,
+                                       nsTArray<nsCString>& aFlavors) {
+  if (!aTransferable) {
+    return NS_ERROR_FAILURE;
+  }
+  // Get a list of flavors this transferable can import
+  nsresult rv = aTransferable->FlavorsTransferableCanImport(aFlavors);
+  if (NS_FAILED(rv)) {
+    LOGCLIP("  FlavorsTransferableCanImport falied!\n");
+    return rv;
+  }
+#ifdef MOZ_LOGGING
+  LOGCLIP("  Flavors which can be imported:");
+  for (const auto& flavor : aFlavors) {
+    LOGCLIP("    %s", flavor.get());
+  }
+#endif
+  return NS_OK;
+}
+
+static bool TransferableSetFile(nsITransferable* aTransferable,
+                                const nsACString& aURIList) {
+  nsresult rv;
+  nsTArray<nsCString> uris = mozilla::widget::ParseTextURIList(aURIList);
+  if (!uris.IsEmpty()) {
+    nsCOMPtr<nsIURI> fileURI;
+    NS_NewURI(getter_AddRefs(fileURI), uris[0]);
+    if (nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(fileURI, &rv)) {
+      nsCOMPtr<nsIFile> file;
+      rv = fileURL->GetFile(getter_AddRefs(file));
+      if (NS_SUCCEEDED(rv)) {
+        aTransferable->SetTransferData(kFileMime, file);
+        LOGCLIP("  successfully set file to clipboard\n");
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+static bool TransferableSetHTML(nsITransferable* aTransferable,
+                                Span<const char> aData) {
+  nsLiteralCString mimeType(kHTMLMime);
+
+  // Convert text/html into our unicode format
+  nsAutoCString charset;
+  if (!GetHTMLCharset(aData, charset)) {
+    // Fall back to utf-8 in case html/data is missing kHTMLMarkupPrefix.
+    LOGCLIP("Failed to get html/text encoding, fall back to utf-8.\n");
+    charset.AssignLiteral("utf-8");
+  }
+
+  LOGCLIP("TransferableSetHTML: HTML detected charset %s", charset.get());
+  // app which use "text/html" to copy&paste
+  // get the decoder
+  auto encoding = Encoding::ForLabelNoReplacement(charset);
+  if (!encoding) {
+    LOGCLIP("TransferableSetHTML: get unicode decoder error (charset: %s)",
+            charset.get());
+    return false;
+  }
+
+  // According to spec html UTF-16BE/LE should be switched to UTF-8
+  // https://html.spec.whatwg.org/#determining-the-character-encoding:utf-16-encoding-2
+  if (encoding == UTF_16LE_ENCODING || encoding == UTF_16BE_ENCODING) {
+    encoding = UTF_8_ENCODING;
+  }
+
+  // Remove kHTMLMarkupPrefix again, it won't necessarily cause any
+  // issues, but might confuse other users.
+  const size_t prefixLen = ArrayLength(kHTMLMarkupPrefix) - 1;
+  if (aData.Length() >= prefixLen && nsDependentCSubstring(aData.To(prefixLen))
+                                         .EqualsLiteral(kHTMLMarkupPrefix)) {
+    aData = aData.From(prefixLen);
+  }
+
+  nsAutoString unicodeData;
+  auto [rv, enc] = encoding->Decode(AsBytes(aData), unicodeData);
+#if MOZ_LOGGING
+  if (enc != UTF_8_ENCODING &&
+      MOZ_LOG_TEST(gClipboardLog, mozilla::LogLevel::Debug)) {
+    nsCString decoderName;
+    enc->Name(decoderName);
+    LOGCLIP("TransferableSetHTML: expected UTF-8 decoder but got %s",
+            decoderName.get());
+  }
+#endif
+  if (NS_FAILED(rv)) {
+    LOGCLIP("TransferableSetHTML: failed to decode HTML");
+    return false;
+  }
+  SetTransferableData(aTransferable, mimeType,
+                      (const char*)unicodeData.BeginReading(),
+                      unicodeData.Length() * sizeof(char16_t));
+  return true;
+}
+
+NS_IMETHODIMP
+nsClipboard::GetData(nsITransferable* aTransferable, int32_t aWhichClipboard) {
+  LOGCLIP("nsClipboard::GetData (%s)\n",
+          aWhichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+
+  // TODO: Ensure we don't re-enter here.
+  if (!mContext) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsTArray<nsCString> flavors;
+  nsresult rv = GetTransferableFlavors(aTransferable, flavors);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Filter out MIME types on X11 to prevent unwanted conversions,
+  // see Bug 1611407
+  if (widget::GdkIsX11Display() &&
+      !FilterImportedFlavors(aWhichClipboard, flavors)) {
+    LOGCLIP("    Missing suitable clipboard data, quit.");
+    return NS_OK;
+  }
+
+  for (uint32_t i = 0; i < flavors.Length(); i++) {
+    nsCString& flavorStr = flavors[i];
+
+    if (flavorStr.EqualsLiteral(kJPEGImageMime) ||
+        flavorStr.EqualsLiteral(kJPGImageMime) ||
+        flavorStr.EqualsLiteral(kPNGImageMime) ||
+        flavorStr.EqualsLiteral(kGIFImageMime)) {
+      // Emulate support for image/jpg
+      if (flavorStr.EqualsLiteral(kJPGImageMime)) {
+        flavorStr.Assign(kJPEGImageMime);
+      }
+
+      LOGCLIP("    Getting image %s MIME clipboard data\n", flavorStr.get());
+
+      auto clipboardData =
+          mContext->GetClipboardData(flavorStr.get(), aWhichClipboard);
+      if (!clipboardData) {
+        LOGCLIP("    %s type is missing\n", flavorStr.get());
+        continue;
+      }
+
+      nsCOMPtr<nsIInputStream> byteStream;
+      NS_NewByteInputStream(getter_AddRefs(byteStream), clipboardData.AsSpan(),
+                            NS_ASSIGNMENT_COPY);
+      aTransferable->SetTransferData(flavorStr.get(), byteStream);
+      LOGCLIP("    got %s MIME data\n", flavorStr.get());
+      return NS_OK;
+    }
+
+    // Special case text/unicode since we can convert any
+    // string into text/unicode
+    if (flavorStr.EqualsLiteral(kUnicodeMime)) {
+      LOGCLIP("    Getting unicode %s MIME clipboard data\n", flavorStr.get());
+
+      auto clipboardData = mContext->GetClipboardText(aWhichClipboard);
+      if (!clipboardData) {
+        LOGCLIP("    failed to get unicode data\n");
+        // If the type was text/unicode and we couldn't get
+        // text off the clipboard, run the next loop
+        // iteration.
+        continue;
+      }
+
+      // Convert utf-8 into our unicode format.
+      NS_ConvertUTF8toUTF16 ucs2string(clipboardData.get());
+      SetTransferableData(aTransferable, flavorStr,
+                          (const char*)ucs2string.BeginReading(),
+                          ucs2string.Length() * 2);
+
+      LOGCLIP("    got unicode data, length %zd\n", ucs2string.Length());
+      return NS_OK;
+    }
+
+    if (flavorStr.EqualsLiteral(kFileMime)) {
+      LOGCLIP("    Getting %s file clipboard data\n", flavorStr.get());
+
+      auto clipboardData =
+          mContext->GetClipboardData(kURIListMime, aWhichClipboard);
+      if (!clipboardData) {
+        LOGCLIP("    text/uri-list type is missing\n");
+        continue;
+      }
+
+      nsDependentCSubstring fileName(clipboardData.AsSpan());
+      if (!TransferableSetFile(aTransferable, fileName)) {
+        continue;
+      }
+      return NS_OK;
+    }
+
+    LOGCLIP("    Getting %s MIME clipboard data\n", flavorStr.get());
+
+    auto clipboardData =
+        mContext->GetClipboardData(flavorStr.get(), aWhichClipboard);
+
+#ifdef MOZ_LOGGING
+    if (!clipboardData) {
+      LOGCLIP("    %s type is missing\n", flavorStr.get());
+    }
+#endif
+
+    if (clipboardData) {
+      LOGCLIP("    got %s mime type data.\n", flavorStr.get());
+
+      // Special case text/html since we can convert into UCS2
+      if (flavorStr.EqualsLiteral(kHTMLMime)) {
+        if (!TransferableSetHTML(aTransferable, clipboardData.AsSpan())) {
+          continue;
+        }
+      } else {
+        auto span = clipboardData.AsSpan();
+        SetTransferableData(aTransferable, flavorStr, span.data(),
+                            span.Length());
+      }
+      return NS_OK;
+    }
+  }
+
+  LOGCLIP("    failed to get clipboard content.\n");
+  return NS_OK;
+}
+
+enum DataType {
+  DATATYPE_IMAGE,
+  DATATYPE_FILE,
+  DATATYPE_HTML,
+  DATATYPE_RAW,
+};
+
+struct DataPromiseHandler {
+  RefPtr<nsITransferable> mTransferable;
+  RefPtr<GenericPromise::Private> mDataPromise;
+  nsCString mMimeType;
+  DataType mDataType;
+
+  explicit DataPromiseHandler(RefPtr<nsITransferable> aTransferable,
+                              RefPtr<GenericPromise::Private> aDataPromise,
+                              const char* aMimeType,
+                              DataType aDataType = DATATYPE_RAW)
+      : mTransferable(std::move(aTransferable)),
+        mDataPromise(std::move(aDataPromise)),
+        mMimeType(aMimeType),
+        mDataType(aDataType) {
+    MOZ_COUNT_CTOR(DataPromiseHandler);
+    LOGCLIP("DataPromiseHandler created [%p] MIME %s type %d", this,
+            mMimeType.get(), mDataType);
+  }
+  ~DataPromiseHandler() {
+    LOGCLIP("DataPromiseHandler deleted [%p]", this);
+    MOZ_COUNT_DTOR(DataPromiseHandler);
+  }
+};
+
+static RefPtr<GenericPromise> AsyncGetTextImpl(nsITransferable* aTransferable,
+                                               int32_t aWhichClipboard) {
+  LOGCLIP("AsyncGetText() type '%s'",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard");
+
+  RefPtr<GenericPromise::Private> dataPromise =
+      new GenericPromise::Private(__func__);
+
+  gtk_clipboard_request_text(
+      gtk_clipboard_get(GetSelectionAtom(aWhichClipboard)),
+      [](GtkClipboard* aClipboard, const gchar* aText, gpointer aData) -> void {
+        UniquePtr<DataPromiseHandler> ref(
+            static_cast<DataPromiseHandler*>(aData));
+        LOGCLIP("AsyncGetText async handler of [%p]", aData);
+
+        size_t dataLength = aText ? strlen(aText) : 0;
+        if (dataLength <= 0) {
+          ref->mDataPromise->Resolve(false, __func__);
+          LOGCLIP("  quit, text is not available");
+          return;
+        }
+
+        // Convert utf-8 into our unicode format.
+        NS_ConvertUTF8toUTF16 utf16string(aText, dataLength);
+        nsLiteralCString flavor(kUnicodeMime);
+        SetTransferableData(ref->mTransferable, flavor,
+                            (const char*)utf16string.BeginReading(),
+                            utf16string.Length() * 2);
+        LOGCLIP("  text is set, length = %d", (int)dataLength);
+        ref->mDataPromise->Resolve(true, __func__);
+      },
+      new DataPromiseHandler(aTransferable, dataPromise, kUnicodeMime));
+
+  return dataPromise;
+}
+
+static RefPtr<GenericPromise> AsyncGetDataImpl(nsITransferable* aTransferable,
+                                               int32_t aWhichClipboard,
+                                               const char* aMimeType,
+                                               DataType aDataType) {
+  LOGCLIP("AsyncGetText() type '%s'",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard");
+
+  RefPtr<GenericPromise::Private> dataPromise =
+      new GenericPromise::Private(__func__);
+
+  const char* gtkMIMEType = nullptr;
+  switch (aDataType) {
+    case DATATYPE_FILE:
+      // Don't ask Gtk for application/x-moz-file
+      gtkMIMEType = kURIListMime;
+      break;
+    case DATATYPE_IMAGE:
+    case DATATYPE_HTML:
+    case DATATYPE_RAW:
+      gtkMIMEType = aMimeType;
+      break;
+  }
+
+  gtk_clipboard_request_contents(
+      gtk_clipboard_get(GetSelectionAtom(aWhichClipboard)),
+      gdk_atom_intern(gtkMIMEType, FALSE),
+      [](GtkClipboard* aClipboard, GtkSelectionData* aSelection,
+         gpointer aData) -> void {
+        UniquePtr<DataPromiseHandler> ref(
+            static_cast<DataPromiseHandler*>(aData));
+        LOGCLIP("AsyncGetData async handler [%p] MIME %s type %d", aData,
+                ref->mMimeType.get(), ref->mDataType);
+
+        int dataLength = gtk_selection_data_get_length(aSelection);
+        if (dataLength <= 0) {
+          ref->mDataPromise->Resolve(false, __func__);
+          return;
+        }
+        const char* data = (const char*)gtk_selection_data_get_data(aSelection);
+        if (!data) {
+          ref->mDataPromise->Resolve(false, __func__);
+          return;
+        }
+        switch (ref->mDataType) {
+          case DATATYPE_IMAGE: {
+            LOGCLIP("  set image clipboard data");
+            nsCOMPtr<nsIInputStream> byteStream;
+            NS_NewByteInputStream(getter_AddRefs(byteStream),
+                                  Span(data, dataLength), NS_ASSIGNMENT_COPY);
+            ref->mTransferable->SetTransferData(ref->mMimeType.get(),
+                                                byteStream);
+            break;
+          }
+          case DATATYPE_FILE: {
+            LOGCLIP("  set file clipboard data");
+            nsDependentCSubstring file(data, dataLength);
+            TransferableSetFile(ref->mTransferable, file);
+            break;
+          }
+          case DATATYPE_HTML: {
+            LOGCLIP("  html clipboard data");
+            Span dataSpan(data, dataLength);
+            TransferableSetHTML(ref->mTransferable, dataSpan);
+            break;
+          }
+          case DATATYPE_RAW: {
+            LOGCLIP("  raw clipboard data %s", ref->mMimeType.get());
+            SetTransferableData(ref->mTransferable, ref->mMimeType, data,
+                                dataLength);
+            break;
+          }
+        }
+        ref->mDataPromise->Resolve(true, __func__);
+      },
+      new DataPromiseHandler(aTransferable, dataPromise, aMimeType, aDataType));
+  return dataPromise;
+}
+
+static RefPtr<GenericPromise> AsyncGetDataFlavor(nsITransferable* aTransferable,
+                                                 int32_t aWhichClipboard,
+                                                 nsCString& aFlavorStr) {
+  if (aFlavorStr.EqualsLiteral(kJPEGImageMime) ||
+      aFlavorStr.EqualsLiteral(kJPGImageMime) ||
+      aFlavorStr.EqualsLiteral(kPNGImageMime) ||
+      aFlavorStr.EqualsLiteral(kGIFImageMime)) {
+    // Emulate support for image/jpg
+    if (aFlavorStr.EqualsLiteral(kJPGImageMime)) {
+      aFlavorStr.Assign(kJPEGImageMime);
+    }
+    LOGCLIP("  Getting image %s MIME clipboard data", aFlavorStr.get());
+    return AsyncGetDataImpl(aTransferable, aWhichClipboard, aFlavorStr.get(),
+                            DATATYPE_IMAGE);
+  }
+  // Special case text/unicode since we can convert any
+  // string into text/unicode
+  if (aFlavorStr.EqualsLiteral(kUnicodeMime)) {
+    LOGCLIP("  Getting unicode clipboard data");
+    return AsyncGetTextImpl(aTransferable, aWhichClipboard);
+  }
+  if (aFlavorStr.EqualsLiteral(kFileMime)) {
+    LOGCLIP("  Getting file clipboard data\n");
+    return AsyncGetDataImpl(aTransferable, aWhichClipboard, aFlavorStr.get(),
+                            DATATYPE_FILE);
+  }
+  if (aFlavorStr.EqualsLiteral(kHTMLMime)) {
+    LOGCLIP("  Getting HTML clipboard data");
+    return AsyncGetDataImpl(aTransferable, aWhichClipboard, aFlavorStr.get(),
+                            DATATYPE_HTML);
+  }
+  LOGCLIP("  Getting raw %s MIME clipboard data\n", aFlavorStr.get());
+  return AsyncGetDataImpl(aTransferable, aWhichClipboard, aFlavorStr.get(),
+                          DATATYPE_RAW);
+}
+
+RefPtr<GenericPromise> nsClipboard::AsyncGetData(nsITransferable* aTransferable,
+                                                 int32_t aWhichClipboard) {
+  LOGCLIP("nsClipboard::AsyncGetData (%s)",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard");
+  nsTArray<nsCString> importedFlavors;
+  nsresult rv = GetTransferableFlavors(aTransferable, importedFlavors);
+  NS_ENSURE_SUCCESS(rv, GenericPromise::CreateAndReject(rv, __func__));
+
+  auto flavorsNum = importedFlavors.Length();
+  if (!flavorsNum) {
+    return GenericPromise::CreateAndResolve(false, __func__);
+  }
+#ifdef MOZ_LOGGING
+  if (flavorsNum > 1) {
+    LOGCLIP("  Only first MIME type (%s) will be imported from clipboard!",
+            importedFlavors[0].get());
+  }
+#endif
+
+  // Filter out MIME types on X11 to prevent unwanted conversions,
+  // see Bug 1611407
+  if (widget::GdkIsX11Display()) {
+    return AsyncHasDataMatchingFlavors(importedFlavors, aWhichClipboard)
+        ->Then(
+            GetMainThreadSerialEventTarget(), __func__,
+            /* resolve */
+            [transferable = RefPtr{aTransferable},
+             aWhichClipboard](nsTArray<nsCString> clipboardFlavors) {
+              if (!clipboardFlavors.Length()) {
+                LOGCLIP("  no flavors in clipboard, quit.");
+                return GenericPromise::CreateAndResolve(false, __func__);
+              }
+              return AsyncGetDataFlavor(transferable, aWhichClipboard,
+                                        clipboardFlavors[0]);
+            },
+            /* reject */
+            [](nsresult rv) {
+              LOGCLIP("  failed to get flavors from clipboard, quit.");
+              return GenericPromise::CreateAndReject(rv, __func__);
+            });
+  }
+
+  // Read clipboard directly on Wayland
+  return AsyncGetDataFlavor(aTransferable, aWhichClipboard, importedFlavors[0]);
+}
+
+NS_IMETHODIMP
+nsClipboard::EmptyClipboard(int32_t aWhichClipboard) {
+  LOGCLIP("nsClipboard::EmptyClipboard (%s)\n",
+          aWhichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+  if (aWhichClipboard == kSelectionClipboard) {
+    if (mSelectionTransferable) {
+      gtk_clipboard_clear(gtk_clipboard_get(GDK_SELECTION_PRIMARY));
+      MOZ_ASSERT(!mSelectionTransferable);
+    }
+  } else {
+    if (mGlobalTransferable) {
+      gtk_clipboard_clear(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
+      MOZ_ASSERT(!mGlobalTransferable);
+    }
+  }
+  ClearCachedTargets(aWhichClipboard);
+  return NS_OK;
+}
+
+void nsClipboard::ClearTransferable(int32_t aWhichClipboard) {
+  if (aWhichClipboard == kSelectionClipboard) {
+    if (mSelectionOwner) {
+      mSelectionOwner->LosingOwnership(mSelectionTransferable);
+      mSelectionOwner = nullptr;
+    }
+    mSelectionTransferable = nullptr;
+  } else {
+    if (mGlobalOwner) {
+      mGlobalOwner->LosingOwnership(mGlobalTransferable);
+      mGlobalOwner = nullptr;
+    }
+    mGlobalTransferable = nullptr;
+  }
+}
+
+static bool FlavorMatchesTarget(const nsACString& aFlavor, GdkAtom aTarget) {
+  GUniquePtr<gchar> atom_name(gdk_atom_name(aTarget));
+  if (!atom_name) {
+    return false;
+  }
+  if (aFlavor.Equals(atom_name.get())) {
+    LOGCLIP("    has %s\n", atom_name.get());
+    return true;
+  }
+  // X clipboard supports image/jpeg, but we want to emulate support
+  // for image/jpg as well
+  if (aFlavor.EqualsLiteral(kJPGImageMime) &&
+      !strcmp(atom_name.get(), kJPEGImageMime)) {
+    LOGCLIP("    has image/jpg\n");
+    return true;
+  }
+  // application/x-moz-file should be treated like text/uri-list
+  if (aFlavor.EqualsLiteral(kFileMime) &&
+      !strcmp(atom_name.get(), kURIListMime)) {
+    LOGCLIP("    has text/uri-list treating as application/x-moz-file");
+    return true;
+  }
+  return false;
+}
+
+NS_IMETHODIMP
+nsClipboard::HasDataMatchingFlavors(const nsTArray<nsCString>& aFlavorList,
+                                    int32_t aWhichClipboard, bool* _retval) {
+  if (!_retval) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  LOGCLIP("nsClipboard::HasDataMatchingFlavors (%s)\n",
+          aWhichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+
+  *_retval = false;
+
+  if (!mContext) {
+    return NS_ERROR_FAILURE;
+  }
+
+  auto targets = mContext->GetTargets(aWhichClipboard);
+  if (!targets) {
+    LOGCLIP("    no targes at clipboard (null)\n");
+    return NS_OK;
+  }
+
+#ifdef MOZ_LOGGING
+  if (LOGCLIP_ENABLED()) {
+    LOGCLIP("    Asking for content:\n");
+    for (auto& flavor : aFlavorList) {
+      LOGCLIP("        MIME %s\n", flavor.get());
+    }
+    LOGCLIP("    Clipboard content (target nums %zu):\n",
+            targets.AsSpan().Length());
+    for (const auto& target : targets.AsSpan()) {
+      GUniquePtr<gchar> atom_name(gdk_atom_name(target));
+      if (!atom_name) {
+        LOGCLIP("        failed to get MIME\n");
+        continue;
+      }
+      LOGCLIP("        MIME %s\n", atom_name.get());
+    }
+  }
+#endif
+
+  // Walk through the provided types and try to match it to a
+  // provided type.
+  for (auto& flavor : aFlavorList) {
+    // We special case text/unicode here.
+    if (flavor.EqualsLiteral(kUnicodeMime) &&
+        gtk_targets_include_text(targets.AsSpan().data(),
+                                 targets.AsSpan().Length())) {
+      *_retval = true;
+      LOGCLIP("    has kUnicodeMime\n");
+      return NS_OK;
+    }
+    for (const auto& target : targets.AsSpan()) {
+      if (FlavorMatchesTarget(flavor, target)) {
+        *_retval = true;
+        return NS_OK;
+      }
+    }
+  }
+
+  LOGCLIP("    no targes at clipboard (bad match)\n");
+  return NS_OK;
+}
+
+struct TragetPromiseHandler {
+  TragetPromiseHandler(const nsTArray<nsCString>& aAcceptedFlavorList,
+                       RefPtr<DataFlavorsPromise::Private> aTargetsPromise)
+      : mAcceptedFlavorList(aAcceptedFlavorList.Clone()),
+        mTargetsPromise(aTargetsPromise) {
+    LOGCLIP("TragetPromiseHandler(%p) created", this);
+  }
+  ~TragetPromiseHandler() { LOGCLIP("TragetPromiseHandler(%p) deleted", this); }
+  nsTArray<nsCString> mAcceptedFlavorList;
+  RefPtr<DataFlavorsPromise::Private> mTargetsPromise;
+};
+
+RefPtr<DataFlavorsPromise> nsClipboard::AsyncHasDataMatchingFlavors(
+    const nsTArray<nsCString>& aFlavorList, int32_t aWhichClipboard) {
+  LOGCLIP("nsClipboard::AsyncHasDataMatchingFlavors() type %s",
+          aWhichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+
+  RefPtr<DataFlavorsPromise::Private> flavorPromise =
+      new DataFlavorsPromise::Private(__func__);
+  gtk_clipboard_request_contents(
+      gtk_clipboard_get(GetSelectionAtom(aWhichClipboard)),
+      gdk_atom_intern("TARGETS", FALSE),
+      [](GtkClipboard* aClipboard, GtkSelectionData* aSelection,
+         gpointer aData) -> void {
+        LOGCLIP("gtk_clipboard_request_contents async handler (%p)", aData);
+        UniquePtr<TragetPromiseHandler> handler(
+            static_cast<TragetPromiseHandler*>(aData));
+
+        GdkAtom* targets = nullptr;
+        gint targetsNum = 0;
+        if (gtk_selection_data_get_length(aSelection) > 0) {
+          gtk_selection_data_get_targets(aSelection, &targets, &targetsNum);
+        }
+        nsTArray<nsCString> results;
+        if (targetsNum) {
+          for (auto& flavor : handler->mAcceptedFlavorList) {
+            LOGCLIP("  looking for %s", flavor.get());
+            // We can convert any text to unicode.
+            if (flavor.EqualsLiteral(kUnicodeMime) &&
+                gtk_targets_include_text(targets, targetsNum)) {
+              results.AppendElement(flavor);
+              LOGCLIP("    has kUnicodeMime\n");
+              continue;
+            }
+            for (int i = 0; i < targetsNum; i++) {
+              if (FlavorMatchesTarget(flavor, targets[i])) {
+                results.AppendElement(flavor);
+              }
+            }
+          }
+        }
+        handler->mTargetsPromise->Resolve(std::move(results), __func__);
+      },
+      new TragetPromiseHandler(aFlavorList, flavorPromise));
+
+  return flavorPromise.forget();
+}
+
+NS_IMETHODIMP
+nsClipboard::SupportsSelectionClipboard(bool* _retval) {
+  *_retval = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsClipboard::SupportsFindClipboard(bool* _retval) {
+  *_retval = false;
+  return NS_OK;
+}
+
+nsITransferable* nsClipboard::GetTransferable(int32_t aWhichClipboard) {
+  nsITransferable* retval;
+
+  if (aWhichClipboard == kSelectionClipboard)
+    retval = mSelectionTransferable.get();
+  else
+    retval = mGlobalTransferable.get();
+
+  return retval;
+}
+
+void nsClipboard::SelectionGetEvent(GtkClipboard* aClipboard,
+                                    GtkSelectionData* aSelectionData) {
+  // Someone has asked us to hand them something.  The first thing
+  // that we want to do is see if that something includes text.  If
+  // it does, try to give it text/unicode after converting it to
+  // utf-8.
+
+  int32_t whichClipboard;
+
+  // which clipboard?
+  GdkAtom selection = gtk_selection_data_get_selection(aSelectionData);
+  if (selection == GDK_SELECTION_PRIMARY)
+    whichClipboard = kSelectionClipboard;
+  else if (selection == GDK_SELECTION_CLIPBOARD)
+    whichClipboard = kGlobalClipboard;
+  else
+    return;  // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
+
+  LOGCLIP("nsClipboard::SelectionGetEvent (%s)\n",
+          whichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+
+  nsCOMPtr<nsITransferable> trans = GetTransferable(whichClipboard);
+  if (!trans) {
+    // We have nothing to serve
+    LOGCLIP("nsClipboard::SelectionGetEvent() - %s clipboard is empty!\n",
+            whichClipboard == kSelectionClipboard ? "Primary" : "Clipboard");
+    return;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsISupports> item;
+
+  GdkAtom selectionTarget = gtk_selection_data_get_target(aSelectionData);
+  LOGCLIP("  selection target %s\n",
+          GUniquePtr<gchar>(gdk_atom_name(selectionTarget)).get());
+
+  // Check to see if the selection data is some text type.
+  if (gtk_targets_include_text(&selectionTarget, 1)) {
+    LOGCLIP("  providing text/unicode data\n");
+    // Try to convert our internal type into a text string.  Get
+    // the transferable for this clipboard and try to get the
+    // text/unicode type for it.
+    rv = trans->GetTransferData("text/unicode", getter_AddRefs(item));
+    if (NS_FAILED(rv) || !item) {
+      LOGCLIP("  GetTransferData() failed to get text/unicode!\n");
+      return;
+    }
+
+    nsCOMPtr<nsISupportsString> wideString;
+    wideString = do_QueryInterface(item);
+    if (!wideString) return;
+
+    nsAutoString ucs2string;
+    wideString->GetData(ucs2string);
+    NS_ConvertUTF16toUTF8 utf8string(ucs2string);
+
+    LOGCLIP("  sent %zd bytes of utf-8 data\n", utf8string.Length());
+    if (selectionTarget == gdk_atom_intern("text/plain;charset=utf-8", FALSE)) {
+      LOGCLIP(
+          "  using gtk_selection_data_set for 'text/plain;charset=utf-8'\n");
+      // Bypass gtk_selection_data_set_text, which will convert \n to \r\n
+      // in some versions of GTK.
+      gtk_selection_data_set(aSelectionData, selectionTarget, 8,
+                             reinterpret_cast<const guchar*>(utf8string.get()),
+                             utf8string.Length());
+    } else {
+      gtk_selection_data_set_text(aSelectionData, utf8string.get(),
+                                  utf8string.Length());
+    }
+    return;
+  }
+
+  // Check to see if the selection data is an image type
+  if (gtk_targets_include_image(&selectionTarget, 1, TRUE)) {
+    LOGCLIP("  providing image data\n");
+    // Look through our transfer data for the image
+    static const char* const imageMimeTypes[] = {kNativeImageMime,
+                                                 kPNGImageMime, kJPEGImageMime,
+                                                 kJPGImageMime, kGIFImageMime};
+    nsCOMPtr<nsISupports> imageItem;
+    nsCOMPtr<imgIContainer> image;
+    for (uint32_t i = 0; i < ArrayLength(imageMimeTypes); i++) {
+      rv = trans->GetTransferData(imageMimeTypes[i], getter_AddRefs(imageItem));
+      if (NS_FAILED(rv)) {
+        LOGCLIP("    %s is missing at GetTransferData()\n", imageMimeTypes[i]);
+        continue;
+      }
+
+      image = do_QueryInterface(imageItem);
+      if (image) {
+        LOGCLIP("    %s is available at GetTransferData()\n",
+                imageMimeTypes[i]);
+        break;
+      }
+    }
+
+    if (!image) {  // Not getting an image for an image mime type!?
+      LOGCLIP("    Failed to get any image mime from GetTransferData()!\n");
+      return;
+    }
+
+    RefPtr<GdkPixbuf> pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
+    if (!pixbuf) {
+      LOGCLIP("    nsImageToPixbuf::ImageToPixbuf() failed!\n");
+      return;
+    }
+
+    LOGCLIP("    Setting pixbuf image data as %s\n",
+            GUniquePtr<gchar>(gdk_atom_name(selectionTarget)).get());
+    gtk_selection_data_set_pixbuf(aSelectionData, pixbuf);
+    return;
+  }
+
+  if (selectionTarget == gdk_atom_intern(kHTMLMime, FALSE)) {
+    LOGCLIP("  providing %s data\n", kHTMLMime);
+    rv = trans->GetTransferData(kHTMLMime, getter_AddRefs(item));
+    if (NS_FAILED(rv) || !item) {
+      LOGCLIP("  failed to get %s data by GetTransferData()!\n", kHTMLMime);
+      return;
+    }
+
+    nsCOMPtr<nsISupportsString> wideString;
+    wideString = do_QueryInterface(item);
+    if (!wideString) {
+      LOGCLIP("  failed to get wideString interface!");
+      return;
+    }
+
+    nsAutoString ucs2string;
+    wideString->GetData(ucs2string);
+
+    nsAutoCString html;
+    // Add the prefix so the encoding is correctly detected.
+    html.AppendLiteral(kHTMLMarkupPrefix);
+    AppendUTF16toUTF8(ucs2string, html);
+
+    LOGCLIP("  Setting %zd bytest of %s data\n", html.Length(),
+            GUniquePtr<gchar>(gdk_atom_name(selectionTarget)).get());
+    gtk_selection_data_set(aSelectionData, selectionTarget, 8,
+                           (const guchar*)html.get(), html.Length());
+    return;
+  }
+
+  LOGCLIP("  Try if we have anything at GetTransferData() for %s\n",
+          GUniquePtr<gchar>(gdk_atom_name(selectionTarget)).get());
+
+  // Try to match up the selection data target to something our
+  // transferable provides.
+  GUniquePtr<gchar> target_name(gdk_atom_name(selectionTarget));
+  if (!target_name) {
+    LOGCLIP("  Failed to get target name!\n");
+    return;
+  }
+
+  rv = trans->GetTransferData(target_name.get(), getter_AddRefs(item));
+  // nothing found?
+  if (NS_FAILED(rv) || !item) {
+    LOGCLIP("  Failed to get anything from GetTransferData()!\n");
+    return;
+  }
+
+  void* primitive_data = nullptr;
+  uint32_t dataLen = 0;
+  nsPrimitiveHelpers::CreateDataFromPrimitive(
+      nsDependentCString(target_name.get()), item, &primitive_data, &dataLen);
+  if (!primitive_data) {
+    LOGCLIP("  Failed to get primitive data!\n");
+    return;
+  }
+
+  LOGCLIP("  Setting %s as a primitive data type, %d bytes\n",
+          target_name.get(), dataLen);
+  gtk_selection_data_set(aSelectionData, selectionTarget,
+                         8, /* 8 bits in a unit */
+                         (const guchar*)primitive_data, dataLen);
+  free(primitive_data);
+}
+
+void nsClipboard::ClearCachedTargets(int32_t aWhichClipboard) {
+  if (aWhichClipboard == kSelectionClipboard) {
+    nsRetrievalContext::ClearCachedTargetsPrimary(nullptr, nullptr, nullptr);
+  } else {
+    nsRetrievalContext::ClearCachedTargetsClipboard(nullptr, nullptr, nullptr);
+  }
+}
+
+void nsClipboard::SelectionClearEvent(GtkClipboard* aGtkClipboard) {
+  int32_t whichClipboard = GetGeckoClipboardType(aGtkClipboard);
+  if (whichClipboard < 0) {
+    return;
+  }
+  LOGCLIP("nsClipboard::SelectionClearEvent (%s)\n",
+          whichClipboard == kSelectionClipboard ? "primary" : "clipboard");
+  ClearCachedTargets(whichClipboard);
+  ClearTransferable(whichClipboard);
+}
+
+void clipboard_get_cb(GtkClipboard* aGtkClipboard,
+                      GtkSelectionData* aSelectionData, guint info,
+                      gpointer user_data) {
+  LOGCLIP("clipboard_get_cb() callback\n");
+  nsClipboard* aClipboard = static_cast<nsClipboard*>(user_data);
+  aClipboard->SelectionGetEvent(aGtkClipboard, aSelectionData);
+}
+
+void clipboard_clear_cb(GtkClipboard* aGtkClipboard, gpointer user_data) {
+  LOGCLIP("clipboard_clear_cb() callback\n");
+  nsClipboard* aClipboard = static_cast<nsClipboard*>(user_data);
+  aClipboard->SelectionClearEvent(aGtkClipboard);
+}
+
+/*
+ * This function extracts the encoding label from the subset of HTML internal
+ * encoding declaration syntax that uses the old long form with double quotes
+ * and without spaces around the equals sign between the "content" attribute
+ * name and the attribute value.
+ *
+ * This was added for the sake of an ancient version of StarOffice
+ * in the pre-UTF-8 era in bug 123389. It is unclear if supporting
+ * non-UTF-8 encodings is still necessary and if this function
+ * still needs to exist.
+ *
+ * As of December 2022, both Gecko and LibreOffice emit an UTF-8
+ * declaration that this function successfully extracts "UTF-8" from,
+ * but that's also the default that we fall back on if this function
+ * fails to extract a label.
+ */
+bool GetHTMLCharset(Span<const char> aData, nsCString& aFoundCharset) {
+  // Assume ASCII first to find "charset" info
+  const nsDependentCSubstring htmlStr(aData);
+  nsACString::const_iterator start, end;
+  htmlStr.BeginReading(start);
+  htmlStr.EndReading(end);
+  nsACString::const_iterator valueStart(start), valueEnd(start);
+
+  if (CaseInsensitiveFindInReadable("CONTENT=\"text/html;"_ns, start, end)) {
+    start = end;
+    htmlStr.EndReading(end);
+
+    if (CaseInsensitiveFindInReadable("charset="_ns, start, end)) {
+      valueStart = end;
+      start = end;
+      htmlStr.EndReading(end);
+
+      if (FindCharInReadable('"', start, end)) valueEnd = start;
+    }
+  }
+  // find "charset" in HTML
+  if (valueStart != valueEnd) {
+    aFoundCharset = Substring(valueStart, valueEnd);
+    ToUpperCase(aFoundCharset);
+    return true;
+  }
+  return false;
+}
diff --git a/widget/gtk/nsClipboard.h b/widget/gtk/nsClipboard.h
new file mode 100644
index 0000000000..ad21b19817
--- /dev/null
+++ b/widget/gtk/nsClipboard.h
@@ -0,0 +1,154 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsClipboard_h_
+#define __nsClipboard_h_
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Span.h"
+#include "nsIClipboard.h"
+#include "nsIObserver.h"
+#include "nsCOMPtr.h"
+#include "GUniquePtr.h"
+#include <gtk/gtk.h>
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gClipboardLog;
+#  define LOGCLIP(...) \
+    MOZ_LOG(gClipboardLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#  define LOGCLIP_ENABLED() \
+    MOZ_LOG_TEST(gClipboardLog, mozilla::LogLevel::Debug)
+#else
+#  define LOGCLIP(...)
+#  define LOGCLIP_ENABLED() false
+#endif /* MOZ_LOGGING */
+
+class ClipboardTargets {
+  friend class ClipboardData;
+
+  mozilla::GUniquePtr<GdkAtom> mTargets;
+  uint32_t mCount = 0;
+
+ public:
+  ClipboardTargets() = default;
+  ClipboardTargets(mozilla::GUniquePtr<GdkAtom> aTargets, uint32_t aCount)
+      : mTargets(std::move(aTargets)), mCount(aCount) {}
+
+  void Set(ClipboardTargets);
+  ClipboardTargets Clone();
+  void Clear() {
+    mTargets = nullptr;
+    mCount = 0;
+  };
+
+  mozilla::Span<GdkAtom> AsSpan() const { return {mTargets.get(), mCount}; }
+  explicit operator bool() const { return bool(mTargets); }
+};
+
+class ClipboardData {
+  mozilla::GUniquePtr<char> mData;
+  uint32_t mLength = 0;
+
+ public:
+  ClipboardData() = default;
+
+  void SetData(mozilla::Span<const uint8_t>);
+  void SetText(mozilla::Span<const char>);
+  void SetTargets(ClipboardTargets);
+
+  ClipboardTargets ExtractTargets();
+  mozilla::GUniquePtr<char> ExtractText() {
+    mLength = 0;
+    return std::move(mData);
+  }
+
+  mozilla::Span<char> AsSpan() const { return {mData.get(), mLength}; }
+  explicit operator bool() const { return bool(mData); }
+};
+
+enum class ClipboardDataType { Data, Text, Targets };
+
+class nsRetrievalContext {
+ public:
+  // We intentionally use unsafe thread refcount as clipboard is used in
+  // main thread only.
+  NS_INLINE_DECL_REFCOUNTING(nsRetrievalContext)
+
+  // Get actual clipboard content (GetClipboardData/GetClipboardText).
+  virtual ClipboardData GetClipboardData(const char* aMimeType,
+                                         int32_t aWhichClipboard) = 0;
+  virtual mozilla::GUniquePtr<char> GetClipboardText(
+      int32_t aWhichClipboard) = 0;
+
+  // Get data mime types which can be obtained from clipboard.
+  ClipboardTargets GetTargets(int32_t aWhichClipboard);
+
+  // Clipboard/Primary selection owner changed. Clear internal cached data.
+  static void ClearCachedTargetsClipboard(GtkClipboard* aClipboard,
+                                          GdkEvent* aEvent, gpointer data);
+  static void ClearCachedTargetsPrimary(GtkClipboard* aClipboard,
+                                        GdkEvent* aEvent, gpointer data);
+
+  nsRetrievalContext();
+
+ protected:
+  virtual ClipboardTargets GetTargetsImpl(int32_t aWhichClipboard) = 0;
+  virtual ~nsRetrievalContext();
+
+  static ClipboardTargets sClipboardTargets;
+  static ClipboardTargets sPrimaryTargets;
+};
+
+class nsClipboard : public nsIClipboard, public nsIObserver {
+ public:
+  nsClipboard();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSICLIPBOARD
+
+  // Make sure we are initialized, called from the factory
+  // constructor
+  nsresult Init(void);
+
+  // Someone requested the selection
+  void SelectionGetEvent(GtkClipboard* aGtkClipboard,
+                         GtkSelectionData* aSelectionData);
+  void SelectionClearEvent(GtkClipboard* aGtkClipboard);
+
+ private:
+  virtual ~nsClipboard();
+
+  // Get our hands on the correct transferable, given a specific
+  // clipboard
+  nsITransferable* GetTransferable(int32_t aWhichClipboard);
+
+  void ClearTransferable(int32_t aWhichClipboard);
+  void ClearCachedTargets(int32_t aWhichClipboard);
+
+  bool FilterImportedFlavors(int32_t aWhichClipboard,
+                             nsTArray<nsCString>& aFlavors);
+
+  // Hang on to our owners and transferables so we can transfer data
+  // when asked.
+  nsCOMPtr<nsIClipboardOwner> mSelectionOwner;
+  nsCOMPtr<nsIClipboardOwner> mGlobalOwner;
+  nsCOMPtr<nsITransferable> mSelectionTransferable;
+  nsCOMPtr<nsITransferable> mGlobalTransferable;
+  RefPtr<nsRetrievalContext> mContext;
+};
+
+extern const int kClipboardTimeout;
+extern const int kClipboardFastIterationNum;
+
+GdkAtom GetSelectionAtom(int32_t aWhichClipboard);
+int GetGeckoClipboardType(GtkClipboard* aGtkClipboard);
+
+#endif /* __nsClipboard_h_ */
diff --git a/widget/gtk/nsClipboardWayland.cpp b/widget/gtk/nsClipboardWayland.cpp
new file mode 100644
index 0000000000..d179f242dd
--- /dev/null
+++ b/widget/gtk/nsClipboardWayland.cpp
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsClipboardWayland.h"
+
+#include "AsyncGtkClipboardRequest.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/ScopeExit.h"
+#include "prtime.h"
+
+#include <gtk/gtk.h>
+#include <stdlib.h>
+#include <string.h>
+
+using namespace mozilla;
+
+nsRetrievalContextWayland::nsRetrievalContextWayland() = default;
+
+ClipboardTargets nsRetrievalContextWayland::GetTargetsImpl(
+    int32_t aWhichClipboard) {
+  LOGCLIP("nsRetrievalContextWayland::GetTargetsImpl()\n");
+
+  return WaitForClipboardData(ClipboardDataType::Targets, aWhichClipboard)
+      .ExtractTargets();
+}
+
+ClipboardData nsRetrievalContextWayland::GetClipboardData(
+    const char* aMimeType, int32_t aWhichClipboard) {
+  LOGCLIP("nsRetrievalContextWayland::GetClipboardData() mime %s\n", aMimeType);
+
+  return WaitForClipboardData(ClipboardDataType::Data, aWhichClipboard,
+                              aMimeType);
+}
+
+GUniquePtr<char> nsRetrievalContextWayland::GetClipboardText(
+    int32_t aWhichClipboard) {
+  GdkAtom selection = GetSelectionAtom(aWhichClipboard);
+
+  LOGCLIP("nsRetrievalContextWayland::GetClipboardText(), clipboard %s\n",
+          (selection == GDK_SELECTION_PRIMARY) ? "Primary" : "Selection");
+
+  return WaitForClipboardData(ClipboardDataType::Text, aWhichClipboard)
+      .ExtractText();
+}
+
+ClipboardData nsRetrievalContextWayland::WaitForClipboardData(
+    ClipboardDataType aDataType, int32_t aWhichClipboard,
+    const char* aMimeType) {
+  LOGCLIP("nsRetrievalContextWayland::WaitForClipboardData, MIME %s\n",
+          aMimeType);
+
+  AsyncGtkClipboardRequest request(aDataType, aWhichClipboard, aMimeType);
+  int iteration = 1;
+
+  PRTime entryTime = PR_Now();
+  while (!request.HasCompleted()) {
+    if (iteration++ > kClipboardFastIterationNum) {
+      /* sleep for 10 ms/iteration */
+      PR_Sleep(PR_MillisecondsToInterval(10));
+      if (PR_Now() - entryTime > kClipboardTimeout) {
+        LOGCLIP("  failed to get async clipboard data in time limit\n");
+        break;
+      }
+    }
+    LOGCLIP("doing iteration %d msec %ld ...\n", (iteration - 1),
+            (long)((PR_Now() - entryTime) / 1000));
+    gtk_main_iteration();
+  }
+
+  return request.TakeResult();
+}
diff --git a/widget/gtk/nsClipboardWayland.h b/widget/gtk/nsClipboardWayland.h
new file mode 100644
index 0000000000..cd8dda0772
--- /dev/null
+++ b/widget/gtk/nsClipboardWayland.h
@@ -0,0 +1,28 @@
+/* -*- 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 __nsClipboardWayland_h_
+#define __nsClipboardWayland_h_
+
+#include "mozilla/Mutex.h"
+#include "nsClipboard.h"
+
+class nsRetrievalContextWayland final : public nsRetrievalContext {
+ public:
+  nsRetrievalContextWayland();
+
+  ClipboardData GetClipboardData(const char* aMimeType,
+                                 int32_t aWhichClipboard) override;
+  mozilla::GUniquePtr<char> GetClipboardText(int32_t aWhichClipboard) override;
+  ClipboardTargets GetTargetsImpl(int32_t aWhichClipboard) override;
+
+ private:
+  ClipboardData WaitForClipboardData(ClipboardDataType, int32_t aWhichClipboard,
+                                     const char* aMimeType = nullptr);
+};
+
+#endif /* __nsClipboardWayland_h_ */
diff --git a/widget/gtk/nsClipboardX11.cpp b/widget/gtk/nsClipboardX11.cpp
new file mode 100644
index 0000000000..fc82e0dd8d
--- /dev/null
+++ b/widget/gtk/nsClipboardX11.cpp
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+
+#include "AsyncGtkClipboardRequest.h"
+#include "nsClipboardX11.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/WidgetUtilsGtk.h"
+
+#include <gtk/gtk.h>
+
+// For manipulation of the X event queue
+#include <X11/Xlib.h>
+#include <poll.h>
+#include <gdk/gdkx.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <unistd.h>
+#include "X11UndefineNone.h"
+
+using namespace mozilla;
+
+nsRetrievalContextX11::nsRetrievalContextX11() = default;
+
+static void DispatchSelectionNotifyEvent(GtkWidget* widget, XEvent* xevent) {
+  GdkEvent event = {};
+  event.selection.type = GDK_SELECTION_NOTIFY;
+  event.selection.window = gtk_widget_get_window(widget);
+  event.selection.selection =
+      gdk_x11_xatom_to_atom(xevent->xselection.selection);
+  event.selection.target = gdk_x11_xatom_to_atom(xevent->xselection.target);
+  event.selection.property = gdk_x11_xatom_to_atom(xevent->xselection.property);
+  event.selection.time = xevent->xselection.time;
+
+  gtk_widget_event(widget, &event);
+}
+
+static void DispatchPropertyNotifyEvent(GtkWidget* widget, XEvent* xevent) {
+  GdkWindow* window = gtk_widget_get_window(widget);
+  if ((gdk_window_get_events(window)) & GDK_PROPERTY_CHANGE_MASK) {
+    GdkEvent event = {};
+    event.property.type = GDK_PROPERTY_NOTIFY;
+    event.property.window = window;
+    event.property.atom = gdk_x11_xatom_to_atom(xevent->xproperty.atom);
+    event.property.time = xevent->xproperty.time;
+    event.property.state = xevent->xproperty.state;
+
+    gtk_widget_event(widget, &event);
+  }
+}
+
+struct checkEventContext {
+  GtkWidget* cbWidget;
+  Atom selAtom;
+};
+
+static Bool checkEventProc(Display* display, XEvent* event, XPointer arg) {
+  checkEventContext* context = (checkEventContext*)arg;
+
+  if (event->xany.type == SelectionNotify ||
+      (event->xany.type == PropertyNotify &&
+       event->xproperty.atom == context->selAtom)) {
+    GdkWindow* cbWindow = gdk_x11_window_lookup_for_display(
+        gdk_x11_lookup_xdisplay(display), event->xany.window);
+    if (cbWindow) {
+      GtkWidget* cbWidget = nullptr;
+      gdk_window_get_user_data(cbWindow, (gpointer*)&cbWidget);
+      if (cbWidget && GTK_IS_WIDGET(cbWidget)) {
+        context->cbWidget = cbWidget;
+        return X11True;
+      }
+    }
+  }
+
+  return X11False;
+}
+
+ClipboardData nsRetrievalContextX11::WaitForClipboardData(
+    ClipboardDataType aDataType, int32_t aWhichClipboard,
+    const char* aMimeType) {
+  AsyncGtkClipboardRequest request(aDataType, aWhichClipboard, aMimeType);
+  if (request.HasCompleted()) {
+    // the request completed synchronously
+    return request.TakeResult();
+  }
+
+  GdkDisplay* gdkDisplay = gdk_display_get_default();
+  // gdk_display_get_default() returns null on headless
+  if (widget::GdkIsX11Display(gdkDisplay)) {
+    Display* xDisplay = GDK_DISPLAY_XDISPLAY(gdkDisplay);
+    checkEventContext context;
+    context.cbWidget = nullptr;
+    context.selAtom =
+        gdk_x11_atom_to_xatom(gdk_atom_intern("GDK_SELECTION", FALSE));
+
+    // Send X events which are relevant to the ongoing selection retrieval
+    // to the clipboard widget.  Wait until either the operation completes, or
+    // we hit our timeout.  All other X events remain queued.
+
+    int poll_result;
+
+    struct pollfd pfd;
+    pfd.fd = ConnectionNumber(xDisplay);
+    pfd.events = POLLIN;
+    TimeStamp start = TimeStamp::Now();
+
+    do {
+      XEvent xevent;
+
+      while (XCheckIfEvent(xDisplay, &xevent, checkEventProc,
+                           (XPointer)&context)) {
+        if (xevent.xany.type == SelectionNotify)
+          DispatchSelectionNotifyEvent(context.cbWidget, &xevent);
+        else
+          DispatchPropertyNotifyEvent(context.cbWidget, &xevent);
+
+        if (request.HasCompleted()) {
+          return request.TakeResult();
+        }
+      }
+
+      TimeStamp now = TimeStamp::Now();
+      int timeout = std::max<int>(
+          0, kClipboardTimeout / 1000 - (now - start).ToMilliseconds());
+      poll_result = poll(&pfd, 1, timeout);
+    } while ((poll_result == 1 && (pfd.revents & (POLLHUP | POLLERR)) == 0) ||
+             (poll_result == -1 && errno == EINTR));
+  }
+
+  LOGCLIP("exceeded clipboard timeout");
+  return {};
+}
+
+ClipboardTargets nsRetrievalContextX11::GetTargetsImpl(
+    int32_t aWhichClipboard) {
+  LOGCLIP("nsRetrievalContextX11::GetTargetsImpl(%s)\n",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard");
+  return WaitForClipboardData(ClipboardDataType::Targets, aWhichClipboard)
+      .ExtractTargets();
+}
+
+ClipboardData nsRetrievalContextX11::GetClipboardData(const char* aMimeType,
+                                                      int32_t aWhichClipboard) {
+  LOGCLIP("nsRetrievalContextX11::GetClipboardData(%s) MIME %s\n",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard",
+          aMimeType);
+
+  return WaitForClipboardData(ClipboardDataType::Data, aWhichClipboard,
+                              aMimeType);
+}
+
+GUniquePtr<char> nsRetrievalContextX11::GetClipboardText(
+    int32_t aWhichClipboard) {
+  LOGCLIP("nsRetrievalContextX11::GetClipboardText(%s)\n",
+          aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
+                                                              : "clipboard");
+
+  return WaitForClipboardData(ClipboardDataType::Text, aWhichClipboard)
+      .ExtractText();
+}
diff --git a/widget/gtk/nsClipboardX11.h b/widget/gtk/nsClipboardX11.h
new file mode 100644
index 0000000000..c143222d3a
--- /dev/null
+++ b/widget/gtk/nsClipboardX11.h
@@ -0,0 +1,32 @@
+/* -*- 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 __nsClipboardX11_h_
+#define __nsClipboardX11_h_
+
+#include <gtk/gtk.h>
+
+#include "mozilla/Maybe.h"
+#include "nsClipboard.h"
+
+class nsRetrievalContextX11 : public nsRetrievalContext {
+ public:
+  ClipboardData GetClipboardData(const char* aMimeType,
+                                 int32_t aWhichClipboard) override;
+  mozilla::GUniquePtr<char> GetClipboardText(int32_t aWhichClipboard) override;
+  ClipboardTargets GetTargetsImpl(int32_t aWhichClipboard) override;
+
+  nsRetrievalContextX11();
+
+ private:
+  // Spins X event loop until timing out or being completed.
+  ClipboardData WaitForClipboardData(ClipboardDataType aDataType,
+                                     int32_t aWhichClipboard,
+                                     const char* aMimeType = nullptr);
+};
+
+#endif /* __nsClipboardX11_h_ */
diff --git a/widget/gtk/nsColorPicker.cpp b/widget/gtk/nsColorPicker.cpp
new file mode 100644
index 0000000000..4719710d9e
--- /dev/null
+++ b/widget/gtk/nsColorPicker.cpp
@@ -0,0 +1,253 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <gtk/gtk.h>
+
+#include "mozilla/Maybe.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "nsColor.h"
+#include "nsColorPicker.h"
+#include "nsGtkUtils.h"
+#include "nsIWidget.h"
+#include "WidgetUtils.h"
+#include "nsPIDOMWindow.h"
+
+using mozilla::dom::HTMLInputElement;
+
+NS_IMPL_ISUPPORTS(nsColorPicker, nsIColorPicker)
+
+#if defined(ACTIVATE_GTK3_COLOR_PICKER)
+int nsColorPicker::convertGdkRgbaComponent(gdouble color_component) {
+  // GdkRGBA value is in range [0.0..1.0]. We need something in range [0..255]
+  return color_component * 255 + 0.5;
+}
+
+gdouble nsColorPicker::convertToGdkRgbaComponent(int color_component) {
+  return color_component / 255.0;
+}
+
+GdkRGBA nsColorPicker::convertToRgbaColor(nscolor color) {
+  GdkRGBA result = {convertToGdkRgbaComponent(NS_GET_R(color)),
+                    convertToGdkRgbaComponent(NS_GET_G(color)),
+                    convertToGdkRgbaComponent(NS_GET_B(color)),
+                    convertToGdkRgbaComponent(NS_GET_A(color))};
+
+  return result;
+}
+#else
+int nsColorPicker::convertGdkColorComponent(guint16 color_component) {
+  // GdkColor value is in range [0..65535]. We need something in range [0..255]
+  return (color_component * 255 + 127) / 65535;
+}
+
+guint16 nsColorPicker::convertToGdkColorComponent(int color_component) {
+  return color_component * 65535 / 255;
+}
+
+GdkColor nsColorPicker::convertToGdkColor(nscolor color) {
+  GdkColor result = {0 /* obsolete, unused 'pixel' value */,
+                     convertToGdkColorComponent(NS_GET_R(color)),
+                     convertToGdkColorComponent(NS_GET_G(color)),
+                     convertToGdkColorComponent(NS_GET_B(color))};
+
+  return result;
+}
+
+GtkColorSelection* nsColorPicker::WidgetGetColorSelection(GtkWidget* widget) {
+  return GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(
+      GTK_COLOR_SELECTION_DIALOG(widget)));
+}
+#endif
+
+NS_IMETHODIMP nsColorPicker::Init(mozIDOMWindowProxy* aParent,
+                                  const nsAString& title,
+                                  const nsAString& initialColor,
+                                  const nsTArray<nsString>& aDefaultColors) {
+  auto* parent = nsPIDOMWindowOuter::From(aParent);
+  mParentWidget = mozilla::widget::WidgetUtils::DOMWindowToWidget(parent);
+  mTitle = title;
+  mInitialColor = initialColor;
+  mDefaultColors.Assign(aDefaultColors);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsColorPicker::Open(
+    nsIColorPickerShownCallback* aColorPickerShownCallback) {
+  auto maybeColor = HTMLInputElement::ParseSimpleColor(mInitialColor);
+  if (maybeColor.isNothing()) {
+    return NS_ERROR_FAILURE;
+  }
+  nscolor color = maybeColor.value();
+
+  if (mCallback) {
+    // It means Open has already been called: this is not allowed
+    NS_WARNING("mCallback is already set. Open called twice?");
+    return NS_ERROR_FAILURE;
+  }
+  mCallback = aColorPickerShownCallback;
+
+  NS_ConvertUTF16toUTF8 title(mTitle);
+  GtkWindow* parent_window =
+      GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET));
+
+#if defined(ACTIVATE_GTK3_COLOR_PICKER)
+  GtkWidget* color_chooser =
+      gtk_color_chooser_dialog_new(title.get(), parent_window);
+
+  if (parent_window) {
+    GtkWindow* window = GTK_WINDOW(color_chooser);
+    gtk_window_set_destroy_with_parent(window, TRUE);
+    if (gtk_window_get_modal(parent_window)) {
+      gtk_window_set_modal(window, TRUE);
+    }
+  }
+
+  gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color_chooser), FALSE);
+
+  // Setting the default colors will put them into "Custom" colors list.
+  for (const nsString& defaultColor : mDefaultColors) {
+    if (auto color = HTMLInputElement::ParseSimpleColor(defaultColor)) {
+      GdkRGBA color_rgba = convertToRgbaColor(*color);
+      gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(color_chooser), &color_rgba);
+    }
+  }
+
+  // The initial color needs to be set last.
+  GdkRGBA color_rgba = convertToRgbaColor(color);
+  gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(color_chooser), &color_rgba);
+
+  g_signal_connect(GTK_COLOR_CHOOSER(color_chooser), "color-activated",
+                   G_CALLBACK(OnColorChanged), this);
+#else
+  GtkWidget* color_chooser = gtk_color_selection_dialog_new(title.get());
+
+  if (parent_window) {
+    GtkWindow* window = GTK_WINDOW(color_chooser);
+    gtk_window_set_transient_for(window, parent_window);
+    gtk_window_set_destroy_with_parent(window, TRUE);
+    if (gtk_window_get_modal(parent_window)) {
+      gtk_window_set_modal(window, TRUE);
+    }
+  }
+
+  GdkColor color_gdk = convertToGdkColor(color);
+  gtk_color_selection_set_current_color(WidgetGetColorSelection(color_chooser),
+                                        &color_gdk);
+
+  g_signal_connect(WidgetGetColorSelection(color_chooser), "color-changed",
+                   G_CALLBACK(OnColorChanged), this);
+#endif
+
+  NS_ADDREF_THIS();
+
+  g_signal_connect(color_chooser, "response", G_CALLBACK(OnResponse), this);
+  g_signal_connect(color_chooser, "destroy", G_CALLBACK(OnDestroy), this);
+  gtk_widget_show(color_chooser);
+
+  return NS_OK;
+}
+
+#if defined(ACTIVATE_GTK3_COLOR_PICKER)
+/* static */
+void nsColorPicker::OnColorChanged(GtkColorChooser* color_chooser,
+                                   GdkRGBA* color, gpointer user_data) {
+  static_cast<nsColorPicker*>(user_data)->Update(color);
+}
+
+void nsColorPicker::Update(GdkRGBA* color) {
+  SetColor(color);
+  if (mCallback) {
+    mCallback->Update(mColor);
+  }
+}
+
+void nsColorPicker::SetColor(const GdkRGBA* color) {
+  mColor.Assign('#');
+  mColor += ToHexString(convertGdkRgbaComponent(color->red));
+  mColor += ToHexString(convertGdkRgbaComponent(color->green));
+  mColor += ToHexString(convertGdkRgbaComponent(color->blue));
+}
+#else
+/* static */
+void nsColorPicker::OnColorChanged(GtkColorSelection* colorselection,
+                                   gpointer user_data) {
+  static_cast<nsColorPicker*>(user_data)->Update(colorselection);
+}
+
+void nsColorPicker::Update(GtkColorSelection* colorselection) {
+  ReadValueFromColorSelection(colorselection);
+  if (mCallback) {
+    mCallback->Update(mColor);
+  }
+}
+
+void nsColorPicker::ReadValueFromColorSelection(
+    GtkColorSelection* colorselection) {
+  GdkColor rgba;
+  gtk_color_selection_get_current_color(colorselection, &rgba);
+
+  mColor.Assign('#');
+  mColor += ToHexString(convertGdkColorComponent(rgba.red));
+  mColor += ToHexString(convertGdkColorComponent(rgba.green));
+  mColor += ToHexString(convertGdkColorComponent(rgba.blue));
+}
+#endif
+
+/* static */
+void nsColorPicker::OnResponse(GtkWidget* color_chooser, gint response_id,
+                               gpointer user_data) {
+  static_cast<nsColorPicker*>(user_data)->Done(color_chooser, response_id);
+}
+
+/* static */
+void nsColorPicker::OnDestroy(GtkWidget* color_chooser, gpointer user_data) {
+  static_cast<nsColorPicker*>(user_data)->Done(color_chooser,
+                                               GTK_RESPONSE_CANCEL);
+}
+
+void nsColorPicker::Done(GtkWidget* color_chooser, gint response) {
+  switch (response) {
+    case GTK_RESPONSE_OK:
+    case GTK_RESPONSE_ACCEPT:
+#if defined(ACTIVATE_GTK3_COLOR_PICKER)
+      GdkRGBA color;
+      gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(color_chooser), &color);
+      SetColor(&color);
+#else
+      ReadValueFromColorSelection(WidgetGetColorSelection(color_chooser));
+#endif
+      break;
+    case GTK_RESPONSE_CANCEL:
+    case GTK_RESPONSE_CLOSE:
+    case GTK_RESPONSE_DELETE_EVENT:
+      mColor = mInitialColor;
+      break;
+    default:
+      NS_WARNING("Unexpected response");
+      break;
+  }
+
+  // A "response" signal won't be sent again but "destroy" will be.
+  g_signal_handlers_disconnect_by_func(color_chooser, FuncToGpointer(OnDestroy),
+                                       this);
+
+  gtk_widget_destroy(color_chooser);
+  if (mCallback) {
+    mCallback->Done(mColor);
+    mCallback = nullptr;
+  }
+
+  NS_RELEASE_THIS();
+}
+
+nsString nsColorPicker::ToHexString(int n) {
+  nsString result;
+  if (n <= 0x0F) {
+    result.Append('0');
+  }
+  result.AppendInt(n, 16);
+  return result;
+}
diff --git a/widget/gtk/nsColorPicker.h b/widget/gtk/nsColorPicker.h
new file mode 100644
index 0000000000..d693175717
--- /dev/null
+++ b/widget/gtk/nsColorPicker.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsColorPicker_h__
+#define nsColorPicker_h__
+
+#include <gtk/gtk.h>
+
+#include "nsCOMPtr.h"
+#include "nsIColorPicker.h"
+#include "nsString.h"
+
+// Enable Gtk3 system color picker.
+#define ACTIVATE_GTK3_COLOR_PICKER 1
+
+class nsIWidget;
+
+class nsColorPicker final : public nsIColorPicker {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICOLORPICKER
+
+  nsColorPicker() = default;
+
+ private:
+  ~nsColorPicker() = default;
+
+  static nsString ToHexString(int n);
+
+  static void OnResponse(GtkWidget* dialog, gint response_id,
+                         gpointer user_data);
+  static void OnDestroy(GtkWidget* dialog, gpointer user_data);
+
+#if defined(ACTIVATE_GTK3_COLOR_PICKER)
+  static void OnColorChanged(GtkColorChooser* color_chooser, GdkRGBA* color,
+                             gpointer user_data);
+
+  static int convertGdkRgbaComponent(gdouble color_component);
+  static gdouble convertToGdkRgbaComponent(int color_component);
+  static GdkRGBA convertToRgbaColor(nscolor color);
+
+  void Update(GdkRGBA* color);
+  void SetColor(const GdkRGBA* color);
+#else
+  static void OnColorChanged(GtkColorSelection* colorselection,
+                             gpointer user_data);
+
+  // Conversion functions for color
+  static int convertGdkColorComponent(guint16 color_component);
+  static guint16 convertToGdkColorComponent(int color_component);
+  static GdkColor convertToGdkColor(nscolor color);
+
+  static GtkColorSelection* WidgetGetColorSelection(GtkWidget* widget);
+
+  void Update(GtkColorSelection* colorselection);
+  void ReadValueFromColorSelection(GtkColorSelection* colorselection);
+#endif
+
+  void Done(GtkWidget* dialog, gint response_id);
+
+  nsCOMPtr<nsIWidget> mParentWidget;
+  nsCOMPtr<nsIColorPickerShownCallback> mCallback;
+  nsString mTitle;
+  nsString mColor;
+  nsString mInitialColor;
+  nsTArray<nsString> mDefaultColors;
+};
+
+#endif  // nsColorPicker_h__
diff --git a/widget/gtk/nsDeviceContextSpecG.cpp b/widget/gtk/nsDeviceContextSpecG.cpp
new file mode 100644
index 0000000000..56ad1e9763
--- /dev/null
+++ b/widget/gtk/nsDeviceContextSpecG.cpp
@@ -0,0 +1,409 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsDeviceContextSpecG.h"
+
+#include "mozilla/gfx/PrintPromise.h"
+#include "mozilla/gfx/PrintTargetPDF.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Services.h"
+#include "mozilla/GUniquePtr.h"
+#include "mozilla/WidgetUtilsGtk.h"
+
+#include "plstr.h"
+#include "prenv.h" /* for PR_GetEnv */
+
+#include "nsComponentManagerUtils.h"
+#include "nsIObserverService.h"
+#include "nsPrintfCString.h"
+#include "nsQueryObject.h"
+#include "nsReadableUtils.h"
+#include "nsThreadUtils.h"
+
+#include "nsCUPSShim.h"
+#include "nsPrinterCUPS.h"
+
+#include "nsPrintSettingsGTK.h"
+
+#include "nsIFileStreams.h"
+#include "nsIFile.h"
+#include "nsTArray.h"
+#include "nsThreadUtils.h"
+
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticPrefs_print.h"
+
+#include <dlfcn.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+// To check if we need to use flatpak portal for printing
+#include "nsIGIOService.h"
+
+using namespace mozilla;
+
+using mozilla::gfx::IntSize;
+using mozilla::gfx::PrintEndDocumentPromise;
+using mozilla::gfx::PrintTarget;
+using mozilla::gfx::PrintTargetPDF;
+
+nsDeviceContextSpecGTK::nsDeviceContextSpecGTK()
+    : mGtkPrintSettings(nullptr), mGtkPageSetup(nullptr) {}
+
+nsDeviceContextSpecGTK::~nsDeviceContextSpecGTK() {
+  if (mGtkPageSetup) {
+    g_object_unref(mGtkPageSetup);
+  }
+
+  if (mGtkPrintSettings) {
+    g_object_unref(mGtkPrintSettings);
+  }
+
+  if (mSpoolFile) {
+    mSpoolFile->Remove(false);
+  }
+}
+
+NS_IMPL_ISUPPORTS(nsDeviceContextSpecGTK, nsIDeviceContextSpec)
+
+already_AddRefed<PrintTarget> nsDeviceContextSpecGTK::MakePrintTarget() {
+  double width, height;
+  mPrintSettings->GetEffectiveSheetSize(&width, &height);
+
+  // convert twips to points
+  width /= TWIPS_PER_POINT_FLOAT;
+  height /= TWIPS_PER_POINT_FLOAT;
+
+  // We shouldn't be attempting to get a surface if we've already got a spool
+  // file.
+  MOZ_ASSERT(!mSpoolFile);
+
+  auto stream = [&]() -> nsCOMPtr<nsIOutputStream> {
+    if (mPrintSettings->GetOutputDestination() ==
+        nsIPrintSettings::kOutputDestinationStream) {
+      nsCOMPtr<nsIOutputStream> out;
+      mPrintSettings->GetOutputStream(getter_AddRefs(out));
+      return out;
+    }
+    // Spool file. Use Glib's temporary file function since we're
+    // already dependent on the gtk software stack.
+    gchar* buf;
+    gint fd = g_file_open_tmp("XXXXXX.tmp", &buf, nullptr);
+    if (-1 == fd) {
+      return nullptr;
+    }
+    close(fd);
+    if (NS_FAILED(NS_NewNativeLocalFile(nsDependentCString(buf), false,
+                                        getter_AddRefs(mSpoolFile)))) {
+      unlink(buf);
+      g_free(buf);
+      return nullptr;
+    }
+    mSpoolName = buf;
+    g_free(buf);
+    mSpoolFile->SetPermissions(0600);
+    nsCOMPtr<nsIFileOutputStream> stream =
+        do_CreateInstance("@mozilla.org/network/file-output-stream;1");
+    if (NS_FAILED(stream->Init(mSpoolFile, -1, -1, 0))) {
+      return nullptr;
+    }
+    return stream;
+  }();
+
+  return PrintTargetPDF::CreateOrNull(stream, IntSize::Ceil(width, height));
+}
+
+#define DECLARE_KNOWN_MONOCHROME_SETTING(key_, value_) {"cups-" key_, value_},
+
+struct {
+  const char* mKey;
+  const char* mValue;
+} kKnownMonochromeSettings[] = {
+    CUPS_EACH_MONOCHROME_PRINTER_SETTING(DECLARE_KNOWN_MONOCHROME_SETTING)};
+
+#undef DECLARE_KNOWN_MONOCHROME_SETTING
+
+// https://developer.gnome.org/gtk3/stable/GtkPaperSize.html#gtk-paper-size-new-from-ipp
+static GUniquePtr<GtkPaperSize> GtkPaperSizeFromIpp(const gchar* aIppName,
+                                                    gdouble aWidth,
+                                                    gdouble aHeight) {
+  static auto sPtr = (GtkPaperSize * (*)(const gchar*, gdouble, gdouble))
+      dlsym(RTLD_DEFAULT, "gtk_paper_size_new_from_ipp");
+  if (gtk_check_version(3, 16, 0)) {
+    return nullptr;
+  }
+  return GUniquePtr<GtkPaperSize>(sPtr(aIppName, aWidth, aHeight));
+}
+
+static bool PaperSizeAlmostEquals(GtkPaperSize* aSize,
+                                  GtkPaperSize* aOtherSize) {
+  const double kEpsilon = 1.0;  // millimetres
+  // GTK stores sizes internally in millimetres so just use that.
+  if (fabs(gtk_paper_size_get_height(aSize, GTK_UNIT_MM) -
+           gtk_paper_size_get_height(aOtherSize, GTK_UNIT_MM)) > kEpsilon) {
+    return false;
+  }
+  if (fabs(gtk_paper_size_get_width(aSize, GTK_UNIT_MM) -
+           gtk_paper_size_get_width(aOtherSize, GTK_UNIT_MM)) > kEpsilon) {
+    return false;
+  }
+  return true;
+}
+
+// Prefer the ppd name because some printers don't deal well even with standard
+// ipp names.
+static GUniquePtr<GtkPaperSize> PpdSizeFromIppName(const gchar* aIppName) {
+  static constexpr struct {
+    const char* mCups;
+    const char* mGtk;
+  } kMap[] = {
+      {CUPS_MEDIA_A3, GTK_PAPER_NAME_A3},
+      {CUPS_MEDIA_A4, GTK_PAPER_NAME_A4},
+      {CUPS_MEDIA_A5, GTK_PAPER_NAME_A5},
+      {CUPS_MEDIA_LETTER, GTK_PAPER_NAME_LETTER},
+      {CUPS_MEDIA_LEGAL, GTK_PAPER_NAME_LEGAL},
+      // Other gtk sizes with no standard CUPS constant: _EXECUTIVE and _B5
+  };
+
+  for (const auto& entry : kMap) {
+    if (!strcmp(entry.mCups, aIppName)) {
+      return GUniquePtr<GtkPaperSize>(gtk_paper_size_new(entry.mGtk));
+    }
+  }
+
+  return nullptr;
+}
+
+// This is a horrible workaround for some printer driver bugs that treat custom
+// page sizes different to standard ones. If our paper object matches one of a
+// standard one, use a standard paper size object instead.
+//
+// We prefer ppd to ipp to custom sizes.
+//
+// See bug 414314, bug 1691798, and bug 1717292 for more info.
+static GUniquePtr<GtkPaperSize> GetStandardGtkPaperSize(
+    GtkPaperSize* aGeckoPaperSize) {
+  // We should get an ipp name from cups, try to get a ppd from that first.
+  const gchar* geckoName = gtk_paper_size_get_name(aGeckoPaperSize);
+  if (auto ppd = PpdSizeFromIppName(geckoName)) {
+    return ppd;
+  }
+
+  // We try gtk_paper_size_new_from_ipp next, because even though
+  // gtk_paper_size_new tries to deal with ipp, it has some rounding issues that
+  // the ipp equivalent doesn't have, see
+  // https://gitlab.gnome.org/GNOME/gtk/-/issues/3685.
+  if (auto ipp = GtkPaperSizeFromIpp(
+          geckoName, gtk_paper_size_get_width(aGeckoPaperSize, GTK_UNIT_POINTS),
+          gtk_paper_size_get_height(aGeckoPaperSize, GTK_UNIT_POINTS))) {
+    if (!gtk_paper_size_is_custom(ipp.get())) {
+      if (auto ppd = PpdSizeFromIppName(gtk_paper_size_get_name(ipp.get()))) {
+        return ppd;
+      }
+      return ipp;
+    }
+  }
+
+  GUniquePtr<GtkPaperSize> size(gtk_paper_size_new(geckoName));
+  // gtk_paper_size_is_equal compares just paper names. The name in Gecko
+  // might come from CUPS, which is an ipp size, and gets normalized by gtk.
+  // So check also for the same actual paper size.
+  if (gtk_paper_size_is_equal(size.get(), aGeckoPaperSize) ||
+      PaperSizeAlmostEquals(aGeckoPaperSize, size.get())) {
+    return size;
+  }
+
+  // Not the same after all, so use our custom paper sizes instead.
+  return nullptr;
+}
+
+/** -------------------------------------------------------
+ *  Initialize the nsDeviceContextSpecGTK
+ *  @update   dc 2/15/98
+ *  @update   syd 3/2/99
+ */
+NS_IMETHODIMP nsDeviceContextSpecGTK::Init(nsIPrintSettings* aPS,
+                                           bool aIsPrintPreview) {
+  RefPtr<nsPrintSettingsGTK> settings = do_QueryObject(aPS);
+  if (!settings) {
+    return NS_ERROR_NO_INTERFACE;
+  }
+  mPrintSettings = aPS;
+
+  mGtkPrintSettings = settings->GetGtkPrintSettings();
+  mGtkPageSetup = settings->GetGtkPageSetup();
+
+  GtkPaperSize* geckoPaperSize = gtk_page_setup_get_paper_size(mGtkPageSetup);
+  GUniquePtr<GtkPaperSize> gtkPaperSize =
+      GetStandardGtkPaperSize(geckoPaperSize);
+
+  mGtkPageSetup = gtk_page_setup_copy(mGtkPageSetup);
+  mGtkPrintSettings = gtk_print_settings_copy(mGtkPrintSettings);
+
+  if (!aPS->GetPrintInColor() && StaticPrefs::print_cups_monochrome_enabled()) {
+    for (const auto& setting : kKnownMonochromeSettings) {
+      gtk_print_settings_set(mGtkPrintSettings, setting.mKey, setting.mValue);
+    }
+    auto applySetting = [&](const nsACString& aKey, const nsACString& aVal) {
+      nsAutoCString extra;
+      extra.AppendASCII("cups-");
+      extra.Append(aKey);
+      gtk_print_settings_set(mGtkPrintSettings, extra.get(),
+                             nsAutoCString(aVal).get());
+    };
+    nsPrinterCUPS::ForEachExtraMonochromeSetting(applySetting);
+  }
+
+  GtkPaperSize* properPaperSize =
+      gtkPaperSize ? gtkPaperSize.get() : geckoPaperSize;
+  gtk_print_settings_set_paper_size(mGtkPrintSettings, properPaperSize);
+  gtk_page_setup_set_paper_size_and_default_margins(mGtkPageSetup,
+                                                    properPaperSize);
+  return NS_OK;
+}
+
+static void print_callback(GtkPrintJob* aJob, gpointer aData,
+                           const GError* aError) {
+  g_object_unref(aJob);
+  ((nsIFile*)aData)->Remove(false);
+}
+
+/* static */
+gboolean nsDeviceContextSpecGTK::PrinterEnumerator(GtkPrinter* aPrinter,
+                                                   gpointer aData) {
+  nsDeviceContextSpecGTK* spec = (nsDeviceContextSpecGTK*)aData;
+
+  // Find the printer whose name matches the one inside the settings.
+  nsString printerName;
+  nsresult rv = spec->mPrintSettings->GetPrinterName(printerName);
+  if (NS_SUCCEEDED(rv) && !printerName.IsVoid()) {
+    NS_ConvertUTF16toUTF8 requestedName(printerName);
+    const char* currentName = gtk_printer_get_name(aPrinter);
+    if (requestedName.Equals(currentName)) {
+      nsPrintSettingsGTK::From(spec->mPrintSettings)->SetGtkPrinter(aPrinter);
+
+      // Bug 1145916 - attempting to kick off a print job for this printer
+      // during this tick of the event loop will result in the printer backend
+      // misunderstanding what the capabilities of the printer are due to a
+      // GTK bug (https://bugzilla.gnome.org/show_bug.cgi?id=753041). We
+      // sidestep this by deferring the print to the next tick.
+      NS_DispatchToCurrentThread(
+          NewRunnableMethod("nsDeviceContextSpecGTK::StartPrintJob", spec,
+                            &nsDeviceContextSpecGTK::StartPrintJob));
+      return TRUE;
+    }
+  }
+
+  // We haven't found it yet - keep searching...
+  return FALSE;
+}
+
+void nsDeviceContextSpecGTK::StartPrintJob() {
+  GtkPrintJob* job = gtk_print_job_new(
+      mTitle.get(), nsPrintSettingsGTK::From(mPrintSettings)->GetGtkPrinter(),
+      mGtkPrintSettings, mGtkPageSetup);
+
+  if (!gtk_print_job_set_source_file(job, mSpoolName.get(), nullptr)) return;
+
+  // Now gtk owns the print job, and will be released via our callback.
+  gtk_print_job_send(job, print_callback, mSpoolFile.forget().take(),
+                     [](gpointer aData) {
+                       auto* spoolFile = static_cast<nsIFile*>(aData);
+                       NS_RELEASE(spoolFile);
+                     });
+}
+
+void nsDeviceContextSpecGTK::EnumeratePrinters() {
+  gtk_enumerate_printers(&nsDeviceContextSpecGTK::PrinterEnumerator, this,
+                         nullptr, TRUE);
+}
+
+NS_IMETHODIMP
+nsDeviceContextSpecGTK::BeginDocument(const nsAString& aTitle,
+                                      const nsAString& aPrintToFileName,
+                                      int32_t aStartPage, int32_t aEndPage) {
+  // Print job names exceeding 255 bytes are safe with GTK version 3.18.2 or
+  // newer. This is a workaround for old GTK.
+  if (gtk_check_version(3, 18, 2) != nullptr) {
+    PrintTarget::AdjustPrintJobNameForIPP(aTitle, mTitle);
+  } else {
+    CopyUTF16toUTF8(aTitle, mTitle);
+  }
+
+  return NS_OK;
+}
+
+RefPtr<PrintEndDocumentPromise> nsDeviceContextSpecGTK::EndDocument() {
+  switch (mPrintSettings->GetOutputDestination()) {
+    case nsIPrintSettings::kOutputDestinationPrinter: {
+      // At this point, we might have a GtkPrinter set up in nsPrintSettingsGTK,
+      // or we might not. In the single-process case, we probably will, as this
+      // is populated by the print settings dialog, or set to the default
+      // printer.
+      // In the multi-process case, we proxy the print settings dialog over to
+      // the parent process, and only get the name of the printer back on the
+      // content process side. In that case, we need to enumerate the printers
+      // on the content side, and find a printer with a matching name.
+
+      if (nsPrintSettingsGTK::From(mPrintSettings)->GetGtkPrinter()) {
+        // We have a printer, so we can print right away.
+        StartPrintJob();
+      } else {
+        // We don't have a printer. We have to enumerate the printers and find
+        // one with a matching name.
+        NS_DispatchToCurrentThread(
+            NewRunnableMethod("nsDeviceContextSpecGTK::EnumeratePrinters", this,
+                              &nsDeviceContextSpecGTK::EnumeratePrinters));
+      }
+      break;
+    }
+    case nsIPrintSettings::kOutputDestinationFile: {
+      // Handle print-to-file ourselves for the benefit of embedders
+      nsString targetPath;
+      nsCOMPtr<nsIFile> destFile;
+      mPrintSettings->GetToFileName(targetPath);
+
+      nsresult rv =
+          NS_NewLocalFile(targetPath, false, getter_AddRefs(destFile));
+      if (NS_FAILED(rv)) {
+        return PrintEndDocumentPromise::CreateAndReject(rv, __func__);
+      }
+
+      return nsIDeviceContextSpec::EndDocumentAsync(
+          __func__,
+          [destFile = std::move(destFile),
+           spoolFile = std::move(mSpoolFile)]() -> nsresult {
+            nsAutoString destLeafName;
+            auto rv = destFile->GetLeafName(destLeafName);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            nsCOMPtr<nsIFile> destDir;
+            rv = destFile->GetParent(getter_AddRefs(destDir));
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            rv = spoolFile->MoveTo(destDir, destLeafName);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            // This is the standard way to get the UNIX umask. Ugh.
+            mode_t mask = umask(0);
+            umask(mask);
+            // If you're not familiar with umasks, they contain the bits of what
+            // NOT to set in the permissions (thats because files and
+            // directories have different numbers of bits for their permissions)
+            destFile->SetPermissions(0666 & ~(mask));
+            return NS_OK;
+          });
+
+      break;
+    }
+    case nsIPrintSettings::kOutputDestinationStream:
+      // Nothing to do, handled in MakePrintTarget.
+      MOZ_ASSERT(!mSpoolFile);
+      break;
+  }
+  return PrintEndDocumentPromise::CreateAndResolve(true, __func__);
+}
diff --git a/widget/gtk/nsDeviceContextSpecG.h b/widget/gtk/nsDeviceContextSpecG.h
new file mode 100644
index 0000000000..eb43053b2b
--- /dev/null
+++ b/widget/gtk/nsDeviceContextSpecG.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsDeviceContextSpecGTK_h___
+#define nsDeviceContextSpecGTK_h___
+
+struct JSContext;
+
+#include "nsIDeviceContextSpec.h"
+#include "nsIPrinterList.h"
+#include "nsIPrintSettings.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/gfx/PrintPromise.h"
+
+#include "nsCRT.h" /* should be <limits.h>? */
+
+#include <gtk/gtk.h>
+#include <gtk/gtkunixprint.h>
+
+#define NS_PORTRAIT 0
+#define NS_LANDSCAPE 1
+
+class nsPrintSettingsGTK;
+
+class nsDeviceContextSpecGTK : public nsIDeviceContextSpec {
+ public:
+  nsDeviceContextSpecGTK();
+
+  NS_DECL_ISUPPORTS
+
+  already_AddRefed<PrintTarget> MakePrintTarget() final;
+
+  NS_IMETHOD Init(nsIPrintSettings* aPS, bool aIsPrintPreview) override;
+  NS_IMETHOD BeginDocument(const nsAString& aTitle,
+                           const nsAString& aPrintToFileName,
+                           int32_t aStartPage, int32_t aEndPage) override;
+  RefPtr<mozilla::gfx::PrintEndDocumentPromise> EndDocument() override;
+  NS_IMETHOD BeginPage() override { return NS_OK; }
+  NS_IMETHOD EndPage() override { return NS_OK; }
+
+ protected:
+  virtual ~nsDeviceContextSpecGTK();
+  GtkPrintSettings* mGtkPrintSettings;
+  GtkPageSetup* mGtkPageSetup;
+
+  nsCString mSpoolName;
+  nsCOMPtr<nsIFile> mSpoolFile;
+  nsCString mTitle;
+
+ private:
+  void EnumeratePrinters();
+  void StartPrintJob();
+  static gboolean PrinterEnumerator(GtkPrinter* aPrinter, gpointer aData);
+};
+
+#endif /* !nsDeviceContextSpecGTK_h___ */
diff --git a/widget/gtk/nsDragService.cpp b/widget/gtk/nsDragService.cpp
new file mode 100644
index 0000000000..a648e57725
--- /dev/null
+++ b/widget/gtk/nsDragService.cpp
@@ -0,0 +1,2680 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsDragService.h"
+#include "nsArrayUtils.h"
+#include "nsIObserverService.h"
+#include "nsWidgetsCID.h"
+#include "nsWindow.h"
+#include "nsSystemInfo.h"
+#include "nsXPCOM.h"
+#include "nsICookieJarSettings.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIIOService.h"
+#include "nsIFileURL.h"
+#include "nsNetUtil.h"
+#include "mozilla/Logging.h"
+#include "nsTArray.h"
+#include "nsPrimitiveHelpers.h"
+#include "prtime.h"
+#include "prthread.h"
+#include <dlfcn.h>
+#include <gtk/gtk.h>
+#include "nsCRT.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/Services.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/WidgetUtilsGtk.h"
+#include "GRefPtr.h"
+#include "nsAppShell.h"
+
+#ifdef MOZ_X11
+#  include "gfxXlibSurface.h"
+#endif
+#include "gfxContext.h"
+#include "nsImageToPixbuf.h"
+#include "nsPresContext.h"
+#include "nsIContent.h"
+#include "mozilla/dom/Document.h"
+#include "nsViewManager.h"
+#include "nsIFrame.h"
+#include "nsGtkUtils.h"
+#include "nsGtkKeyUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "gfxPlatform.h"
+#include "ScreenHelperGTK.h"
+#include "nsArrayUtils.h"
+#include "nsStringStream.h"
+#include "nsDirectoryService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsEscape.h"
+#include "nsString.h"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+//  The maximum time to wait for a "drag_received" arrived in microseconds.
+#define NS_DND_TIMEOUT 1000000
+
+//  The maximum time to wait before temporary files resulting
+//  from drag'n'drop events will be removed in miliseconds.
+//  It's set to 5 min as the file has to be present some time after drop
+//  event to give target application time to get the data.
+//  (A target application can throw a dialog to ask user what to do with
+//  the data and will access the tmp file after user action.)
+#define NS_DND_TMP_CLEANUP_TIMEOUT (1000 * 60 * 5)
+
+#define NS_SYSTEMINFO_CONTRACTID "@mozilla.org/system-info;1"
+
+// This sets how opaque the drag image is
+#define DRAG_IMAGE_ALPHA_LEVEL 0.5
+
+#ifdef MOZ_LOGGING
+extern mozilla::LazyLogModule gWidgetDragLog;
+#  define LOGDRAGSERVICE(str, ...)                    \
+    MOZ_LOG(gWidgetDragLog, mozilla::LogLevel::Debug, \
+            ("[Depth %d]: " str, GetLoopDepth(), ##__VA_ARGS__))
+#  define LOGDRAGSERVICESTATIC(str, ...) \
+    MOZ_LOG(gWidgetDragLog, mozilla::LogLevel::Debug, (str, ##__VA_ARGS__))
+#else
+#  define LOGDRAGSERVICE(...)
+#endif
+
+// Helper class to block native events processing.
+class MOZ_STACK_CLASS AutoSuspendNativeEvents {
+ public:
+  AutoSuspendNativeEvents() {
+    mAppShell = do_GetService(NS_APPSHELL_CID);
+    mAppShell->SuspendNative();
+  }
+  ~AutoSuspendNativeEvents() { mAppShell->ResumeNative(); }
+
+ private:
+  nsCOMPtr<nsIAppShell> mAppShell;
+};
+
+// data used for synthetic periodic motion events sent to the source widget
+// grabbing real events for the drag.
+static guint sMotionEventTimerID;
+
+static GdkEvent* sMotionEvent;
+static GUniquePtr<GdkEvent> TakeMotionEvent() {
+  GUniquePtr<GdkEvent> event(sMotionEvent);
+  sMotionEvent = nullptr;
+  return event;
+}
+static void SetMotionEvent(GUniquePtr<GdkEvent> aEvent) {
+  TakeMotionEvent();
+  sMotionEvent = aEvent.release();
+}
+
+static GtkWidget* sGrabWidget;
+
+static constexpr nsLiteralString kDisallowedExportedSchemes[] = {
+    u"about"_ns,      u"blob"_ns,     u"chrome"_ns,      u"imap"_ns,
+    u"javascript"_ns, u"mailbox"_ns,  u"moz-anno"_ns,    u"news"_ns,
+    u"page-icon"_ns,  u"resource"_ns, u"view-source"_ns, u"moz-extension"_ns,
+};
+
+// _NETSCAPE_URL is similar to text/uri-list type.
+// Format is UTF8: URL + "\n" + title.
+// While text/uri-list tells target application to fetch, copy and store data
+// from URL, _NETSCAPE_URL suggest to create a link to the target.
+// Also _NETSCAPE_URL points to only one item while text/uri-list can point to
+// multiple ones.
+static const char gMozUrlType[] = "_NETSCAPE_URL";
+static const char gMimeListType[] = "application/x-moz-internal-item-list";
+static const char gTextUriListType[] = "text/uri-list";
+static const char gTextPlainUTF8Type[] = "text/plain;charset=utf-8";
+static const char gXdndDirectSaveType[] = "XdndDirectSave0";
+static const char gTabDropType[] = "application/x-moz-tabbrowser-tab";
+
+// See https://docs.gtk.org/gtk3/enum.DragResult.html
+static const char kGtkDragResults[][100]{
+    "GTK_DRAG_RESULT_SUCCESS",        "GTK_DRAG_RESULT_NO_TARGET",
+    "GTK_DRAG_RESULT_USER_CANCELLED", "GTK_DRAG_RESULT_TIMEOUT_EXPIRED",
+    "GTK_DRAG_RESULT_GRAB_BROKEN",    "GTK_DRAG_RESULT_ERROR"};
+
+static void invisibleSourceDragBegin(GtkWidget* aWidget,
+                                     GdkDragContext* aContext, gpointer aData);
+
+static void invisibleSourceDragEnd(GtkWidget* aWidget, GdkDragContext* aContext,
+                                   gpointer aData);
+
+static gboolean invisibleSourceDragFailed(GtkWidget* aWidget,
+                                          GdkDragContext* aContext,
+                                          gint aResult, gpointer aData);
+
+static void invisibleSourceDragDataGet(GtkWidget* aWidget,
+                                       GdkDragContext* aContext,
+                                       GtkSelectionData* aSelectionData,
+                                       guint aInfo, guint32 aTime,
+                                       gpointer aData);
+
+nsDragService::nsDragService()
+    : mScheduledTask(eDragTaskNone),
+      mTaskSource(0),
+      mScheduledTaskIsRunning(false),
+      mCachedDragContext() {
+  // We have to destroy the hidden widget before the event loop stops
+  // running.
+  nsCOMPtr<nsIObserverService> obsServ =
+      mozilla::services::GetObserverService();
+  obsServ->AddObserver(this, "quit-application", false);
+
+  // our hidden source widget
+  // Using an offscreen window works around bug 983843.
+  mHiddenWidget = gtk_offscreen_window_new();
+  // make sure that the widget is realized so that
+  // we can use it as a drag source.
+  gtk_widget_realize(mHiddenWidget);
+  // hook up our internal signals so that we can get some feedback
+  // from our drag source
+  g_signal_connect(mHiddenWidget, "drag_begin",
+                   G_CALLBACK(invisibleSourceDragBegin), this);
+  g_signal_connect(mHiddenWidget, "drag_data_get",
+                   G_CALLBACK(invisibleSourceDragDataGet), this);
+  g_signal_connect(mHiddenWidget, "drag_end",
+                   G_CALLBACK(invisibleSourceDragEnd), this);
+  // drag-failed is available from GTK+ version 2.12
+  guint dragFailedID =
+      g_signal_lookup("drag-failed", G_TYPE_FROM_INSTANCE(mHiddenWidget));
+  if (dragFailedID) {
+    g_signal_connect_closure_by_id(
+        mHiddenWidget, dragFailedID, 0,
+        g_cclosure_new(G_CALLBACK(invisibleSourceDragFailed), this, nullptr),
+        FALSE);
+  }
+
+  // set up our logging module
+  mCanDrop = false;
+  mTargetDragDataReceived = false;
+  mTargetDragData = 0;
+  mTargetDragDataLen = 0;
+  mTempFileTimerID = 0;
+  mEventLoopDepth = 0;
+  LOGDRAGSERVICE("nsDragService::nsDragService");
+}
+
+nsDragService::~nsDragService() {
+  LOGDRAGSERVICE("nsDragService::~nsDragService");
+  if (mTaskSource) g_source_remove(mTaskSource);
+  if (mTempFileTimerID) {
+    g_source_remove(mTempFileTimerID);
+    RemoveTempFiles();
+  }
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsDragService, nsBaseDragService, nsIObserver)
+
+mozilla::StaticRefPtr<nsDragService> sDragServiceInstance;
+/* static */
+already_AddRefed<nsDragService> nsDragService::GetInstance() {
+  if (gfxPlatform::IsHeadless()) {
+    return nullptr;
+  }
+  if (!sDragServiceInstance) {
+    sDragServiceInstance = new nsDragService();
+    ClearOnShutdown(&sDragServiceInstance);
+  }
+
+  RefPtr<nsDragService> service = sDragServiceInstance.get();
+  return service.forget();
+}
+
+// nsIObserver
+
+NS_IMETHODIMP
+nsDragService::Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData) {
+  if (!nsCRT::strcmp(aTopic, "quit-application")) {
+    LOGDRAGSERVICE("nsDragService::Observe(\"quit-application\")");
+    if (mHiddenWidget) {
+      gtk_widget_destroy(mHiddenWidget);
+      mHiddenWidget = 0;
+    }
+    TargetResetData();
+  } else {
+    MOZ_ASSERT_UNREACHABLE("unexpected topic");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  return NS_OK;
+}
+
+// Support for periodic drag events
+
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#drag-and-drop-processing-model
+// and the Xdnd protocol both recommend that drag events are sent periodically,
+// but GTK does not normally provide this.
+//
+// Here GTK is periodically stimulated by copies of the most recent mouse
+// motion events so as to send drag position messages to the destination when
+// appropriate (after it has received a status event from the previous
+// message).
+//
+// (If events were sent only on the destination side then the destination
+// would have no message to which it could reply with a drag status.  Without
+// sending a drag status to the source, the destination would not be able to
+// change its feedback re whether it could accept the drop, and so the
+// source's behavior on drop will not be consistent.)
+
+static gboolean DispatchMotionEventCopy(gpointer aData) {
+  // Clear the timer id before OnSourceGrabEventAfter is called during event
+  // dispatch.
+  sMotionEventTimerID = 0;
+
+  GUniquePtr<GdkEvent> event = TakeMotionEvent();
+  // If there is no longer a grab on the widget, then the drag is over and
+  // there is no need to continue drag motion.
+  if (gtk_widget_has_grab(sGrabWidget)) {
+    gtk_propagate_event(sGrabWidget, event.get());
+  }
+
+  // Cancel this timer;
+  // We've already started another if the motion event was dispatched.
+  return FALSE;
+}
+
+static void OnSourceGrabEventAfter(GtkWidget* widget, GdkEvent* event,
+                                   gpointer user_data) {
+  // If there is no longer a grab on the widget, then the drag motion is
+  // over (though the data may not be fetched yet).
+  if (!gtk_widget_has_grab(sGrabWidget)) return;
+
+  if (event->type == GDK_MOTION_NOTIFY) {
+    SetMotionEvent(GUniquePtr<GdkEvent>(gdk_event_copy(event)));
+
+    // Update the cursor position.  The last of these recorded gets used for
+    // the eDragEnd event.
+    nsDragService* dragService = static_cast<nsDragService*>(user_data);
+    gint scale = mozilla::widget::ScreenHelperGTK::GetGTKMonitorScaleFactor();
+    auto p = LayoutDeviceIntPoint::Round(event->motion.x_root * scale,
+                                         event->motion.y_root * scale);
+    dragService->SetDragEndPoint(p);
+  } else if (sMotionEvent &&
+             (event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE)) {
+    // Update modifier state from key events.
+    sMotionEvent->motion.state = event->key.state;
+  } else {
+    return;
+  }
+
+  if (sMotionEventTimerID) {
+    g_source_remove(sMotionEventTimerID);
+  }
+
+  // G_PRIORITY_DEFAULT_IDLE is lower priority than GDK's redraw idle source
+  // and lower than GTK's idle source that sends drag position messages after
+  // motion-notify signals.
+  //
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#drag-and-drop-processing-model
+  // recommends an interval of 350ms +/- 200ms.
+  sMotionEventTimerID = g_timeout_add_full(
+      G_PRIORITY_DEFAULT_IDLE, 350, DispatchMotionEventCopy, nullptr, nullptr);
+}
+
+static GtkWindow* GetGtkWindow(dom::Document* aDocument) {
+  if (!aDocument) return nullptr;
+
+  PresShell* presShell = aDocument->GetPresShell();
+  if (!presShell) {
+    return nullptr;
+  }
+
+  RefPtr<nsViewManager> vm = presShell->GetViewManager();
+  if (!vm) return nullptr;
+
+  nsCOMPtr<nsIWidget> widget = vm->GetRootWidget();
+  if (!widget) return nullptr;
+
+  GtkWidget* gtkWidget = static_cast<nsWindow*>(widget.get())->GetGtkWidget();
+  if (!gtkWidget) return nullptr;
+
+  GtkWidget* toplevel = nullptr;
+  toplevel = gtk_widget_get_toplevel(gtkWidget);
+  if (!GTK_IS_WINDOW(toplevel)) return nullptr;
+
+  return GTK_WINDOW(toplevel);
+}
+
+// nsIDragService
+
+NS_IMETHODIMP
+nsDragService::InvokeDragSession(
+    nsINode* aDOMNode, nsIPrincipal* aPrincipal, nsIContentSecurityPolicy* aCsp,
+    nsICookieJarSettings* aCookieJarSettings, nsIArray* aArrayTransferables,
+    uint32_t aActionType,
+    nsContentPolicyType aContentPolicyType = nsIContentPolicy::TYPE_OTHER) {
+  LOGDRAGSERVICE("nsDragService::InvokeDragSession");
+
+  // If the previous source drag has not yet completed, signal handlers need
+  // to be removed from sGrabWidget and dragend needs to be dispatched to
+  // the source node, but we can't call EndDragSession yet because we don't
+  // know whether or not the drag succeeded.
+  if (mSourceNode) return NS_ERROR_NOT_AVAILABLE;
+
+  return nsBaseDragService::InvokeDragSession(
+      aDOMNode, aPrincipal, aCsp, aCookieJarSettings, aArrayTransferables,
+      aActionType, aContentPolicyType);
+}
+
+// nsBaseDragService
+nsresult nsDragService::InvokeDragSessionImpl(
+    nsIArray* aArrayTransferables, const Maybe<CSSIntRegion>& aRegion,
+    uint32_t aActionType) {
+  // make sure that we have an array of transferables to use
+  if (!aArrayTransferables) return NS_ERROR_INVALID_ARG;
+  // set our reference to the transferables.  this will also addref
+  // the transferables since we're going to hang onto this beyond the
+  // length of this call
+  mSourceDataItems = aArrayTransferables;
+
+  LOGDRAGSERVICE("nsDragService::InvokeDragSessionImpl");
+
+  // get the list of items we offer for drags
+  GtkTargetList* sourceList = GetSourceList();
+
+  if (!sourceList) return NS_OK;
+
+  // save our action type
+  GdkDragAction action = GDK_ACTION_DEFAULT;
+
+  if (aActionType & DRAGDROP_ACTION_COPY)
+    action = (GdkDragAction)(action | GDK_ACTION_COPY);
+  if (aActionType & DRAGDROP_ACTION_MOVE)
+    action = (GdkDragAction)(action | GDK_ACTION_MOVE);
+  if (aActionType & DRAGDROP_ACTION_LINK)
+    action = (GdkDragAction)(action | GDK_ACTION_LINK);
+
+  GdkEvent* existingEvent = widget::GetLastMousePressEvent();
+  GdkEvent fakeEvent;
+  if (!existingEvent) {
+    // Create a fake event for the drag so we can pass the time (so to speak).
+    // If we don't do this, then, when the timestamp for the pending button
+    // release event is used for the ungrab, the ungrab can fail due to the
+    // timestamp being _earlier_ than CurrentTime.
+    memset(&fakeEvent, 0, sizeof(GdkEvent));
+    fakeEvent.type = GDK_BUTTON_PRESS;
+    fakeEvent.button.window = gtk_widget_get_window(mHiddenWidget);
+    fakeEvent.button.time = nsWindow::GetLastUserInputTime();
+    fakeEvent.button.device = widget::GdkGetPointer();
+  }
+
+  // Put the drag widget in the window group of the source node so that the
+  // gtk_grab_add during gtk_drag_begin is effective.
+  // gtk_window_get_group(nullptr) returns the default window group.
+  GtkWindowGroup* window_group =
+      gtk_window_get_group(GetGtkWindow(mSourceDocument));
+  gtk_window_group_add_window(window_group, GTK_WINDOW(mHiddenWidget));
+
+  // start our drag.
+  GdkDragContext* context = gtk_drag_begin_with_coordinates(
+      mHiddenWidget, sourceList, action, 1,
+      existingEvent ? existingEvent : &fakeEvent, -1, -1);
+
+  if (widget::GdkIsWaylandDisplay() || widget::IsXWaylandProtocol()) {
+    GdkDevice* device = gdk_drag_context_get_device(context);
+    GdkWindow* gdkWindow =
+        gdk_device_get_window_at_position(device, nullptr, nullptr);
+    mSourceWindow = nsWindow::GetWindow(gdkWindow);
+    if (mSourceWindow) {
+      mSourceWindow->SetDragSource(context);
+    }
+  }
+
+  LOGDRAGSERVICE("  GdkDragContext [%p] nsWindow [%p]", context,
+                 mSourceWindow.get());
+
+  nsresult rv;
+  if (context) {
+    StartDragSession();
+
+    // GTK uses another hidden window for receiving mouse events.
+    sGrabWidget = gtk_window_group_get_current_grab(window_group);
+    if (sGrabWidget) {
+      g_object_ref(sGrabWidget);
+      // Only motion and key events are required but connect to
+      // "event-after" as this is never blocked by other handlers.
+      g_signal_connect(sGrabWidget, "event-after",
+                       G_CALLBACK(OnSourceGrabEventAfter), this);
+    }
+    // We don't have a drag end point yet.
+    mEndDragPoint = LayoutDeviceIntPoint(-1, -1);
+    rv = NS_OK;
+  } else {
+    rv = NS_ERROR_FAILURE;
+  }
+
+  gtk_target_list_unref(sourceList);
+
+  return rv;
+}
+
+bool nsDragService::SetAlphaPixmap(SourceSurface* aSurface,
+                                   GdkDragContext* aContext, int32_t aXOffset,
+                                   int32_t aYOffset,
+                                   const LayoutDeviceIntRect& dragRect) {
+  GdkScreen* screen = gtk_widget_get_screen(mHiddenWidget);
+
+  // Transparent drag icons need, like a lot of transparency-related things,
+  // a compositing X window manager
+  if (!gdk_screen_is_composited(screen)) {
+    return false;
+  }
+
+#ifdef cairo_image_surface_create
+#  error "Looks like we're including Mozilla's cairo instead of system cairo"
+#endif
+
+  // TODO: grab X11 pixmap or image data instead of expensive readback.
+  cairo_surface_t* surf = cairo_image_surface_create(
+      CAIRO_FORMAT_ARGB32, dragRect.width, dragRect.height);
+  if (!surf) return false;
+
+  RefPtr<DrawTarget> dt = gfxPlatform::CreateDrawTargetForData(
+      cairo_image_surface_get_data(surf),
+      nsIntSize(dragRect.width, dragRect.height),
+      cairo_image_surface_get_stride(surf), SurfaceFormat::B8G8R8A8);
+  if (!dt) return false;
+
+  dt->ClearRect(Rect(0, 0, dragRect.width, dragRect.height));
+  dt->DrawSurface(
+      aSurface, Rect(0, 0, dragRect.width, dragRect.height),
+      Rect(0, 0, dragRect.width, dragRect.height), DrawSurfaceOptions(),
+      DrawOptions(DRAG_IMAGE_ALPHA_LEVEL, CompositionOp::OP_SOURCE));
+
+  cairo_surface_mark_dirty(surf);
+  cairo_surface_set_device_offset(surf, -aXOffset, -aYOffset);
+
+  // Ensure that the surface is drawn at the correct scale on HiDPI displays.
+  static auto sCairoSurfaceSetDeviceScalePtr =
+      (void (*)(cairo_surface_t*, double, double))dlsym(
+          RTLD_DEFAULT, "cairo_surface_set_device_scale");
+  if (sCairoSurfaceSetDeviceScalePtr) {
+    gint scale = mozilla::widget::ScreenHelperGTK::GetGTKMonitorScaleFactor();
+    sCairoSurfaceSetDeviceScalePtr(surf, scale, scale);
+  }
+
+  gtk_drag_set_icon_surface(aContext, surf);
+  cairo_surface_destroy(surf);
+  return true;
+}
+
+NS_IMETHODIMP
+nsDragService::StartDragSession() {
+  LOGDRAGSERVICE("nsDragService::StartDragSession");
+  mTempFileUrls.Clear();
+  return nsBaseDragService::StartDragSession();
+}
+
+bool nsDragService::RemoveTempFiles() {
+  LOGDRAGSERVICE("nsDragService::RemoveTempFiles");
+
+  // We can not delete the temporary files immediately after the
+  // drag has finished, because the target application might have not
+  // copied the temporary file yet. The Qt toolkit does not provide a
+  // way to mark a drop as finished in an asynchronous way, so most
+  // Qt based applications do send the dnd_finished signal before they
+  // have actually accessed the data from the temporary file.
+  // (https://bugreports.qt.io/browse/QTBUG-5441)
+  //
+  // To work also with these applications we collect all temporary
+  // files in mTemporaryFiles array and remove them here in the timer event.
+  auto files = std::move(mTemporaryFiles);
+  for (nsIFile* file : files) {
+#ifdef MOZ_LOGGING
+    if (MOZ_LOG_TEST(gWidgetDragLog, LogLevel::Debug)) {
+      nsAutoCString path;
+      if (NS_SUCCEEDED(file->GetNativePath(path))) {
+        LOGDRAGSERVICE("  removing %s", path.get());
+      }
+    }
+#endif
+    file->Remove(/* recursive = */ true);
+  }
+  MOZ_ASSERT(mTemporaryFiles.IsEmpty());
+  mTempFileTimerID = 0;
+  // Return false to remove the timer added by g_timeout_add_full().
+  return false;
+}
+
+gboolean nsDragService::TaskRemoveTempFiles(gpointer data) {
+  RefPtr<nsDragService> dragService = static_cast<nsDragService*>(data);
+  return dragService->RemoveTempFiles();
+}
+
+NS_IMETHODIMP
+nsDragService::EndDragSession(bool aDoneDrag, uint32_t aKeyModifiers) {
+  LOGDRAGSERVICE("nsDragService::EndDragSession(%p) %d",
+                 mTargetDragContext.get(), aDoneDrag);
+
+  if (sGrabWidget) {
+    g_signal_handlers_disconnect_by_func(
+        sGrabWidget, FuncToGpointer(OnSourceGrabEventAfter), this);
+    g_object_unref(sGrabWidget);
+    sGrabWidget = nullptr;
+
+    if (sMotionEventTimerID) {
+      g_source_remove(sMotionEventTimerID);
+      sMotionEventTimerID = 0;
+    }
+    if (sMotionEvent) {
+      TakeMotionEvent();
+    }
+  }
+
+  // unset our drag action
+  SetDragAction(DRAGDROP_ACTION_NONE);
+
+  // start timer to remove temporary files
+  if (mTemporaryFiles.Count() > 0 && !mTempFileTimerID) {
+    LOGDRAGSERVICE("  queue removing of temporary files");
+    // |this| won't be used after nsDragService delete because the timer is
+    // removed in the nsDragService destructor.
+    mTempFileTimerID =
+        g_timeout_add(NS_DND_TMP_CLEANUP_TIMEOUT, TaskRemoveTempFiles, this);
+    mTempFileUrls.Clear();
+  }
+
+  // We're done with the drag context.
+  if (mSourceWindow) {
+    mSourceWindow->SetDragSource(nullptr);
+    mSourceWindow = nullptr;
+  }
+  mTargetDragContextForRemote = nullptr;
+  mTargetWindow = nullptr;
+  mPendingWindow = nullptr;
+  mCachedDragContext = 0;
+
+  return nsBaseDragService::EndDragSession(aDoneDrag, aKeyModifiers);
+}
+
+// nsIDragSession
+NS_IMETHODIMP
+nsDragService::SetCanDrop(bool aCanDrop) {
+  LOGDRAGSERVICE("nsDragService::SetCanDrop %d", aCanDrop);
+  mCanDrop = aCanDrop;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDragService::GetCanDrop(bool* aCanDrop) {
+  LOGDRAGSERVICE("nsDragService::GetCanDrop");
+  *aCanDrop = mCanDrop;
+  return NS_OK;
+}
+
+static void UTF16ToNewUTF8(const char16_t* aUTF16, uint32_t aUTF16Len,
+                           char** aUTF8, uint32_t* aUTF8Len) {
+  nsDependentSubstring utf16(aUTF16, aUTF16Len);
+  *aUTF8 = ToNewUTF8String(utf16, aUTF8Len);
+}
+
+static void UTF8ToNewUTF16(const char* aUTF8, uint32_t aUTF8Len,
+                           char16_t** aUTF16, uint32_t* aUTF16Len) {
+  nsDependentCSubstring utf8(aUTF8, aUTF8Len);
+  *aUTF16 = UTF8ToNewUnicode(utf8, aUTF16Len);
+}
+
+// count the number of URIs in some text/uri-list format data.
+static uint32_t CountTextUriListItems(const char* data, uint32_t datalen) {
+  const char* p = data;
+  const char* endPtr = p + datalen;
+  uint32_t count = 0;
+
+  while (p < endPtr) {
+    // skip whitespace (if any)
+    while (p < endPtr && *p != '\0' && isspace(*p)) p++;
+    // if we aren't at the end of the line ...
+    if (p != endPtr && *p != '\0' && *p != '\n' && *p != '\r') count++;
+    // skip to the end of the line
+    while (p < endPtr && *p != '\0' && *p != '\n') p++;
+    p++;  // skip the actual newline as well.
+  }
+  return count;
+}
+
+// extract an item from text/uri-list formatted data and convert it to
+// unicode.
+static void GetTextUriListItem(const char* data, uint32_t datalen,
+                               uint32_t aItemIndex, char16_t** convertedText,
+                               uint32_t* convertedTextLen) {
+  const char* p = data;
+  const char* endPtr = p + datalen;
+  unsigned int count = 0;
+
+  *convertedText = nullptr;
+  while (p < endPtr) {
+    // skip whitespace (if any)
+    while (p < endPtr && *p != '\0' && isspace(*p)) p++;
+    // if we aren't at the end of the line, we have a url
+    if (p != endPtr && *p != '\0' && *p != '\n' && *p != '\r') count++;
+    // this is the item we are after ...
+    if (aItemIndex + 1 == count) {
+      const char* q = p;
+      while (q < endPtr && *q != '\0' && *q != '\n' && *q != '\r') q++;
+      UTF8ToNewUTF16(p, q - p, convertedText, convertedTextLen);
+      break;
+    }
+    // skip to the end of the line
+    while (p < endPtr && *p != '\0' && *p != '\n') p++;
+    p++;  // skip the actual newline as well.
+  }
+
+  // didn't find the desired item, so just pass the whole lot
+  if (!*convertedText) {
+    UTF8ToNewUTF16(data, datalen, convertedText, convertedTextLen);
+  }
+}
+
+// Spins event loop, called from JS.
+// Can lead to another round of drag_motion events.
+NS_IMETHODIMP
+nsDragService::GetNumDropItems(uint32_t* aNumItems) {
+  LOGDRAGSERVICE("nsDragService::GetNumDropItems");
+
+  if (!mTargetWidget) {
+    LOGDRAGSERVICE(
+        "*** warning: GetNumDropItems \
+               called without a valid target widget!\n");
+    *aNumItems = 0;
+    return NS_OK;
+  }
+
+  bool isList = IsTargetContextList();
+  if (isList) {
+    if (!mSourceDataItems) {
+      *aNumItems = 0;
+      return NS_OK;
+    }
+    mSourceDataItems->GetLength(aNumItems);
+  } else {
+    GdkAtom gdkFlavor = gdk_atom_intern(gTextUriListType, FALSE);
+    if (!gdkFlavor) {
+      *aNumItems = 0;
+      return NS_OK;
+    }
+
+    nsTArray<nsCString> dragFlavors;
+    GetDragFlavors(dragFlavors);
+    GetTargetDragData(gdkFlavor, dragFlavors);
+
+    if (mTargetDragData) {
+      const char* data = reinterpret_cast<char*>(mTargetDragData);
+      *aNumItems = CountTextUriListItems(data, mTargetDragDataLen);
+    } else
+      *aNumItems = 1;
+  }
+  LOGDRAGSERVICE("  NumOfDropItems %d", *aNumItems);
+  return NS_OK;
+}
+
+void nsDragService::GetDragFlavors(nsTArray<nsCString>& aFlavors) {
+  for (GList* tmp = gdk_drag_context_list_targets(mTargetDragContext); tmp;
+       tmp = tmp->next) {
+    GdkAtom atom = GDK_POINTER_TO_ATOM(tmp->data);
+    GUniquePtr<gchar> name(gdk_atom_name(atom));
+    if (!name) {
+      continue;
+    }
+    aFlavors.AppendElement(nsCString(name.get()));
+  }
+}
+
+// Spins event loop, called from JS.
+// Can lead to another round of drag_motion events.
+NS_IMETHODIMP
+nsDragService::GetData(nsITransferable* aTransferable, uint32_t aItemIndex) {
+  LOGDRAGSERVICE("nsDragService::GetData(), index %d", aItemIndex);
+
+  // make sure that we have a transferable
+  if (!aTransferable) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (!mTargetWidget) {
+    LOGDRAGSERVICE(
+        "*** failed: GetData called without a valid target widget!\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  // get flavor list that includes all acceptable flavors (including
+  // ones obtained through conversion).
+  nsTArray<nsCString> flavors;
+  nsresult rv = aTransferable->FlavorsTransferableCanImport(flavors);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  failed to get flavors, quit.");
+    return rv;
+  }
+
+  // check to see if this is an internal list
+  bool isList = IsTargetContextList();
+
+  if (isList) {
+    LOGDRAGSERVICE("  Process as a list...");
+    // find a matching flavor
+    for (uint32_t i = 0; i < flavors.Length(); ++i) {
+      nsCString& flavorStr = flavors[i];
+      LOGDRAGSERVICE("  [%d] flavor is %s\n", i, flavorStr.get());
+      // get the item with the right index
+      nsCOMPtr<nsITransferable> item =
+          do_QueryElementAt(mSourceDataItems, aItemIndex);
+      if (!item) continue;
+
+      nsCOMPtr<nsISupports> data;
+      LOGDRAGSERVICE("  trying to get transfer data for %s\n", flavorStr.get());
+      rv = item->GetTransferData(flavorStr.get(), getter_AddRefs(data));
+      if (NS_FAILED(rv)) {
+        LOGDRAGSERVICE("  failed.\n");
+        continue;
+      }
+      rv = aTransferable->SetTransferData(flavorStr.get(), data);
+      if (NS_FAILED(rv)) {
+        LOGDRAGSERVICE("  fail to set transfer data into transferable!\n");
+        continue;
+      }
+      LOGDRAGSERVICE("  succeeded\n");
+      // ok, we got the data
+      return NS_OK;
+    }
+    // if we got this far, we failed
+    LOGDRAGSERVICE("  failed to match flavors\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsTArray<nsCString> dragFlavors;
+  GetDragFlavors(dragFlavors);
+
+  // Now walk down the list of flavors. When we find one that is
+  // actually present, copy out the data into the transferable in that
+  // format. SetTransferData() implicitly handles conversions.
+  for (uint32_t i = 0; i < flavors.Length(); ++i) {
+    nsCString& flavorStr = flavors[i];
+    GdkAtom gdkFlavor = gdk_atom_intern(flavorStr.get(), FALSE);
+    LOGDRAGSERVICE("  we're getting data %s (gdk flavor %p)\n", flavorStr.get(),
+                   gdkFlavor);
+    bool dataFound = false;
+    if (gdkFlavor) {
+      GetTargetDragData(gdkFlavor, dragFlavors);
+    }
+    if (mTargetDragData) {
+      LOGDRAGSERVICE("  dataFound = true\n");
+      dataFound = true;
+    } else {
+      LOGDRAGSERVICE("  dataFound = false, try conversions\n");
+
+      // Dragging and dropping from the file manager would cause us
+      // to parse the source text as a nsIFile URL.
+      if (flavorStr.EqualsLiteral(kFileMime)) {
+        LOGDRAGSERVICE("  conversion %s => %s", kFileMime, gTextUriListType);
+        gdkFlavor = gdk_atom_intern(gTextUriListType, FALSE);
+        GetTargetDragData(gdkFlavor, dragFlavors);
+        if (mTargetDragData) {
+          const char* text = static_cast<char*>(mTargetDragData);
+          char16_t* convertedText = nullptr;
+          uint32_t convertedTextLen = 0;
+
+          GetTextUriListItem(text, mTargetDragDataLen, aItemIndex,
+                             &convertedText, &convertedTextLen);
+
+          if (convertedText) {
+            nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);
+            nsCOMPtr<nsIURI> fileURI;
+            rv = ioService->NewURI(NS_ConvertUTF16toUTF8(convertedText),
+                                   nullptr, nullptr, getter_AddRefs(fileURI));
+            if (NS_SUCCEEDED(rv)) {
+              nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(fileURI, &rv);
+              if (NS_SUCCEEDED(rv)) {
+                nsCOMPtr<nsIFile> file;
+                rv = fileURL->GetFile(getter_AddRefs(file));
+                if (NS_SUCCEEDED(rv)) {
+                  // The common wrapping code at the end of
+                  // this function assumes the data is text
+                  // and calls text-specific operations.
+                  // Make a secret hideout here for nsIFile
+                  // objects and return early.
+                  LOGDRAGSERVICE("  set as file %s",
+                                 NS_ConvertUTF16toUTF8(convertedText).get());
+                  aTransferable->SetTransferData(flavorStr.get(), file);
+                  g_free(convertedText);
+                  return NS_OK;
+                }
+              }
+            }
+            g_free(convertedText);
+          }
+          continue;
+        }
+      }
+
+      // if we are looking for text/unicode and we fail to find it
+      // on the clipboard first, try again with text/plain. If that
+      // is present, convert it to unicode.
+      if (flavorStr.EqualsLiteral(kUnicodeMime)) {
+        LOGDRAGSERVICE("  conversion %s => %s", kUnicodeMime,
+                       gTextPlainUTF8Type);
+        gdkFlavor = gdk_atom_intern(gTextPlainUTF8Type, FALSE);
+        GetTargetDragData(gdkFlavor, dragFlavors);
+        if (mTargetDragData) {
+          const char* castedText = reinterpret_cast<char*>(mTargetDragData);
+          char16_t* convertedText = nullptr;
+          NS_ConvertUTF8toUTF16 ucs2string(castedText, mTargetDragDataLen);
+          convertedText = ToNewUnicode(ucs2string, mozilla::fallible);
+          if (convertedText) {
+            // out with the old, in with the new
+            g_free(mTargetDragData);
+            mTargetDragData = convertedText;
+            mTargetDragDataLen = ucs2string.Length() * 2;
+            dataFound = true;
+          }  // if plain text data on clipboard
+        } else {
+          LOGDRAGSERVICE("  conversion %s => %s", kUnicodeMime, kTextMime);
+          gdkFlavor = gdk_atom_intern(kTextMime, FALSE);
+          GetTargetDragData(gdkFlavor, dragFlavors);
+          if (mTargetDragData) {
+            const char* castedText = reinterpret_cast<char*>(mTargetDragData);
+            char16_t* convertedText = nullptr;
+            uint32_t convertedTextLen = 0;
+            UTF8ToNewUTF16(castedText, mTargetDragDataLen, &convertedText,
+                           &convertedTextLen);
+            if (convertedText) {
+              // out with the old, in with the new
+              g_free(mTargetDragData);
+              mTargetDragData = convertedText;
+              mTargetDragDataLen = convertedTextLen * 2;
+              dataFound = true;
+            }  // if plain text data on clipboard
+          }    // if plain text flavor present
+        }      // if plain text charset=utf-8 flavor present
+      }        // if looking for text/unicode
+
+      // if we are looking for text/x-moz-url and we failed to find
+      // it on the clipboard, try again with text/uri-list, and then
+      // _NETSCAPE_URL
+      if (flavorStr.EqualsLiteral(kURLMime)) {
+        LOGDRAGSERVICE("  conversion %s => %s", kURLMime, gTextUriListType);
+        gdkFlavor = gdk_atom_intern(gTextUriListType, FALSE);
+        GetTargetDragData(gdkFlavor, dragFlavors);
+        if (mTargetDragData) {
+          const char* data = reinterpret_cast<char*>(mTargetDragData);
+          char16_t* convertedText = nullptr;
+          uint32_t convertedTextLen = 0;
+
+          GetTextUriListItem(data, mTargetDragDataLen, aItemIndex,
+                             &convertedText, &convertedTextLen);
+
+          if (convertedText) {
+            // out with the old, in with the new
+            g_free(mTargetDragData);
+            mTargetDragData = convertedText;
+            mTargetDragDataLen = convertedTextLen * 2;
+            dataFound = true;
+          }
+        }
+        if (!dataFound) {
+          LOGDRAGSERVICE("  conversion %s => %s", kURLMime, gMozUrlType);
+          gdkFlavor = gdk_atom_intern(gMozUrlType, FALSE);
+          GetTargetDragData(gdkFlavor, dragFlavors);
+          if (mTargetDragData) {
+            const char* castedText = reinterpret_cast<char*>(mTargetDragData);
+            char16_t* convertedText = nullptr;
+            uint32_t convertedTextLen = 0;
+            UTF8ToNewUTF16(castedText, mTargetDragDataLen, &convertedText,
+                           &convertedTextLen);
+            if (convertedText) {
+              // out with the old, in with the new
+              g_free(mTargetDragData);
+              mTargetDragData = convertedText;
+              mTargetDragDataLen = convertedTextLen * 2;
+              dataFound = true;
+            }
+          }
+        }
+      }
+
+    }  // else we try one last ditch effort to find our data
+
+    if (dataFound) {
+      LOGDRAGSERVICE("  actual data found %s\n",
+                     GUniquePtr<gchar>(gdk_atom_name(gdkFlavor)).get());
+
+      if (flavorStr.EqualsLiteral(kJPEGImageMime) ||
+          flavorStr.EqualsLiteral(kJPGImageMime) ||
+          flavorStr.EqualsLiteral(kPNGImageMime) ||
+          flavorStr.EqualsLiteral(kGIFImageMime)) {
+        LOGDRAGSERVICE("  saving as image %s\n", flavorStr.get());
+
+        nsCOMPtr<nsIInputStream> byteStream;
+        NS_NewByteInputStream(getter_AddRefs(byteStream),
+                              Span((char*)mTargetDragData, mTargetDragDataLen),
+                              NS_ASSIGNMENT_COPY);
+        aTransferable->SetTransferData(flavorStr.get(), byteStream);
+        continue;
+      }
+
+      if (!flavorStr.EqualsLiteral(kCustomTypesMime)) {
+        // the DOM only wants LF, so convert from MacOS line endings
+        // to DOM line endings.
+        nsLinebreakHelpers::ConvertPlatformToDOMLinebreaks(
+            flavorStr, &mTargetDragData,
+            reinterpret_cast<int*>(&mTargetDragDataLen));
+      }
+
+      // put it into the transferable.
+      nsCOMPtr<nsISupports> genericDataWrapper;
+      nsPrimitiveHelpers::CreatePrimitiveForData(
+          flavorStr, mTargetDragData, mTargetDragDataLen,
+          getter_AddRefs(genericDataWrapper));
+      aTransferable->SetTransferData(flavorStr.get(), genericDataWrapper);
+      // we found one, get out of this loop!
+      break;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDragService::IsDataFlavorSupported(const char* aDataFlavor, bool* _retval) {
+  LOGDRAGSERVICE("nsDragService::IsDataFlavorSupported(%p) %s",
+                 mTargetDragContext.get(), aDataFlavor);
+  if (!_retval) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // set this to no by default
+  *_retval = false;
+
+  // check to make sure that we have a drag object set, here
+  if (!mTargetWidget) {
+    LOGDRAGSERVICE(
+        "*** warning: IsDataFlavorSupported called without a valid target "
+        "widget!\n");
+    return NS_OK;
+  }
+
+  // check to see if the target context is a list.
+  bool isList = IsTargetContextList();
+  // if it is, just look in the internal data since we are the source
+  // for it.
+  if (isList) {
+    LOGDRAGSERVICE("  It's a list");
+    uint32_t numDragItems = 0;
+    // if we don't have mDataItems we didn't start this drag so it's
+    // an external client trying to fool us.
+    if (!mSourceDataItems) {
+      LOGDRAGSERVICE("  quit");
+      return NS_OK;
+    }
+    mSourceDataItems->GetLength(&numDragItems);
+    LOGDRAGSERVICE("  drag items %d", numDragItems);
+    for (uint32_t itemIndex = 0; itemIndex < numDragItems; ++itemIndex) {
+      nsCOMPtr<nsITransferable> currItem =
+          do_QueryElementAt(mSourceDataItems, itemIndex);
+      if (currItem) {
+        nsTArray<nsCString> flavors;
+        currItem->FlavorsTransferableCanExport(flavors);
+        for (uint32_t i = 0; i < flavors.Length(); ++i) {
+          LOGDRAGSERVICE("  checking %s against %s\n", flavors[i].get(),
+                         aDataFlavor);
+          if (flavors[i].Equals(aDataFlavor)) {
+            LOGDRAGSERVICE("  found.\n");
+            *_retval = true;
+          }
+        }
+      }
+    }
+    return NS_OK;
+  }
+
+  // check the target context vs. this flavor, one at a time
+  GList* tmp = nullptr;
+  if (mTargetDragContext) {
+    tmp = gdk_drag_context_list_targets(mTargetDragContext);
+  }
+
+  for (; tmp; tmp = tmp->next) {
+    /* Bug 331198 */
+    GdkAtom atom = GDK_POINTER_TO_ATOM(tmp->data);
+    GUniquePtr<gchar> name(gdk_atom_name(atom));
+    if (!name) {
+      continue;
+    }
+
+    if (strcmp(name.get(), aDataFlavor) == 0) {
+      *_retval = true;
+    }
+    // check for automatic text/uri-list -> text/x-moz-url mapping
+    else if (strcmp(name.get(), gTextUriListType) == 0 &&
+             (strcmp(aDataFlavor, kURLMime) == 0 ||
+              strcmp(aDataFlavor, kFileMime) == 0)) {
+      *_retval = true;
+    }
+    // check for automatic _NETSCAPE_URL -> text/x-moz-url mapping
+    else if (strcmp(name.get(), gMozUrlType) == 0 &&
+             (strcmp(aDataFlavor, kURLMime) == 0)) {
+      *_retval = true;
+    }
+    // check for auto text/plain -> text/unicode mapping
+    else if (strcmp(name.get(), kTextMime) == 0 &&
+             (strcmp(aDataFlavor, kUnicodeMime) == 0)) {
+      *_retval = true;
+    }
+
+    if (*_retval) {
+      LOGDRAGSERVICE("  supported, with converting %s => %s", name.get(),
+                     aDataFlavor);
+    }
+  }
+
+  if (!*_retval) {
+    LOGDRAGSERVICE("  %s is not supported", aDataFlavor);
+  }
+
+  return NS_OK;
+}
+
+void nsDragService::ReplyToDragMotion(GdkDragContext* aDragContext,
+                                      guint aTime) {
+  LOGDRAGSERVICE("nsDragService::ReplyToDragMotion(%p) can drop %d",
+                 aDragContext, mCanDrop);
+
+  GdkDragAction action = (GdkDragAction)0;
+  if (mCanDrop) {
+    // notify the dragger if we can drop
+    switch (mDragAction) {
+      case DRAGDROP_ACTION_COPY:
+        LOGDRAGSERVICE("  set explicit action copy");
+        action = GDK_ACTION_COPY;
+        break;
+      case DRAGDROP_ACTION_LINK:
+        LOGDRAGSERVICE("  set explicit action link");
+        action = GDK_ACTION_LINK;
+        break;
+      case DRAGDROP_ACTION_NONE:
+        LOGDRAGSERVICE("  set explicit action none");
+        action = (GdkDragAction)0;
+        break;
+      default:
+        LOGDRAGSERVICE("  set explicit action move");
+        action = GDK_ACTION_MOVE;
+        break;
+    }
+  } else {
+    LOGDRAGSERVICE("  mCanDrop is false, disable drop");
+  }
+
+  // gdk_drag_status() is a kind of red herring here.
+  // It does not control final D&D operation type (copy/move) but controls
+  // drop/no-drop D&D state and default cursor type (copy/move).
+
+  // Actual D&D operation is determined by mDragAction which is set by
+  // SetDragAction() from UpdateDragAction() or gecko/layout.
+
+  // State passed to gdk_drag_status() sets default D&D cursor type
+  // which can be switched by key control (CTRL/SHIFT).
+  // If user changes D&D cursor (and D&D operation) we're notified by
+  // gdk_drag_context_get_selected_action() and update mDragAction.
+
+  // But if we pass mDragAction back to gdk_drag_status() the D&D operation
+  // becames locked and won't be returned when D&D modifiers (CTRL/SHIFT)
+  // are released.
+
+  // This gdk_drag_context_get_selected_action() -> gdk_drag_status() ->
+  // gdk_drag_context_get_selected_action() cycle happens on Wayland.
+  if (widget::GdkIsWaylandDisplay() && action == GDK_ACTION_COPY) {
+    LOGDRAGSERVICE("  Wayland: switch copy to move");
+    action = GDK_ACTION_MOVE;
+  }
+
+  LOGDRAGSERVICE("  gdk_drag_status() action %d", action);
+  gdk_drag_status(aDragContext, action, aTime);
+}
+
+void nsDragService::EnsureCachedDataValidForContext(
+    GdkDragContext* aDragContext) {
+  if (mCachedDragContext != (uintptr_t)aDragContext) {
+    mCachedData.Clear();
+    mCachedDragContext = (uintptr_t)aDragContext;
+  }
+}
+
+void nsDragService::TargetDataReceived(GtkWidget* aWidget,
+                                       GdkDragContext* aContext, gint aX,
+                                       gint aY,
+                                       GtkSelectionData* aSelectionData,
+                                       guint aInfo, guint32 aTime) {
+  LOGDRAGSERVICE("nsDragService::TargetDataReceived(%p)", aContext);
+  TargetResetData();
+
+  EnsureCachedDataValidForContext(aContext);
+
+  mTargetDragDataReceived = true;
+  gint len = gtk_selection_data_get_length(aSelectionData);
+  const guchar* data = gtk_selection_data_get_data(aSelectionData);
+
+  GdkAtom target = gtk_selection_data_get_target(aSelectionData);
+  GUniquePtr<gchar> name(gdk_atom_name(target));
+  nsDependentCString flavor(name.get());
+
+  LOGDRAGSERVICE("  got data, MIME %s", flavor.get());
+
+  if (len > 0 && data) {
+    mTargetDragDataLen = len;
+    mTargetDragData = g_malloc(mTargetDragDataLen);
+    memcpy(mTargetDragData, data, mTargetDragDataLen);
+
+    LOGDRAGSERVICE("  got data, len = %d", mTargetDragDataLen);
+
+    nsTArray<uint8_t> copy;
+    if (!copy.SetLength(len, fallible)) {
+      return;
+    }
+    memcpy(copy.Elements(), data, len);
+
+    mCachedData.InsertOrUpdate(flavor, std::move(copy));
+  } else {
+    LOGDRAGSERVICE("Failed to get data. selection data len was %d\n",
+                   mTargetDragDataLen);
+    mCachedData.InsertOrUpdate(flavor, nsTArray<uint8_t>());
+  }
+}
+
+bool nsDragService::IsTargetContextList(void) {
+  bool retval = false;
+
+  // gMimeListType drags only work for drags within a single process. The
+  // gtk_drag_get_source_widget() function will return nullptr if the source
+  // of the drag is another app, so we use it to check if a gMimeListType
+  // drop will work or not.
+  if (mTargetDragContext &&
+      gtk_drag_get_source_widget(mTargetDragContext) == nullptr) {
+    return retval;
+  }
+
+  GList* tmp = nullptr;
+  if (mTargetDragContext) {
+    tmp = gdk_drag_context_list_targets(mTargetDragContext);
+  }
+
+  // walk the list of context targets and see if one of them is a list
+  // of items.
+  for (; tmp; tmp = tmp->next) {
+    /* Bug 331198 */
+    GdkAtom atom = GDK_POINTER_TO_ATOM(tmp->data);
+    GUniquePtr<gchar> name(gdk_atom_name(atom));
+    if (name && !strcmp(name.get(), gMimeListType)) {
+      return true;
+    }
+  }
+
+  return retval;
+}
+
+// Spins event loop, called from eDragTaskMotion handler by
+// DispatchMotionEvents().
+// Can lead to another round of drag_motion events.
+void nsDragService::GetTargetDragData(GdkAtom aFlavor,
+                                      nsTArray<nsCString>& aDropFlavors) {
+  LOGDRAGSERVICE("nsDragService::GetTargetDragData(%p) '%s'\n",
+                 mTargetDragContext.get(),
+                 GUniquePtr<gchar>(gdk_atom_name(aFlavor)).get());
+
+  // reset our target data areas
+  TargetResetData();
+
+  GUniquePtr<gchar> name(gdk_atom_name(aFlavor));
+  nsDependentCString flavor(name.get());
+
+  // Return early when requested MIME is not offered by D&D.
+  if (!aDropFlavors.Contains(flavor)) {
+    LOGDRAGSERVICE("  %s is missing", flavor.get());
+    return;
+  }
+
+  if (mTargetDragContext) {
+    // We keep a copy of the requested data with the same life-time
+    // as mTargetDragContext.
+    // Especially with multiple items the same data is requested
+    // very often.
+    EnsureCachedDataValidForContext(mTargetDragContext);
+    if (auto cached = mCachedData.Lookup(flavor)) {
+      mTargetDragDataLen = cached->Length();
+      LOGDRAGSERVICE("  using cached data for %s, length is %d", flavor.get(),
+                     mTargetDragDataLen);
+
+      if (mTargetDragDataLen) {
+        mTargetDragData = g_malloc(mTargetDragDataLen);
+        memcpy(mTargetDragData, cached->Elements(), mTargetDragDataLen);
+      }
+
+      mTargetDragDataReceived = true;
+      LOGDRAGSERVICE("  %s found in cache", flavor.get());
+      return;
+    }
+
+    gtk_drag_get_data(mTargetWidget, mTargetDragContext, aFlavor, mTargetTime);
+
+    LOGDRAGSERVICE("  about to start inner iteration.");
+    gtk_main_iteration();
+
+    PRTime entryTime = PR_Now();
+    while (!mTargetDragDataReceived && mDoingDrag) {
+      // check the number of iterations
+      LOGDRAGSERVICE("  doing iteration...\n");
+      PR_Sleep(PR_MillisecondsToInterval(10)); /* sleep for 10 ms/iteration */
+      if (PR_Now() - entryTime > NS_DND_TIMEOUT) {
+        LOGDRAGSERVICE("  failed to get D&D data in time!\n");
+        break;
+      }
+      gtk_main_iteration();
+    }
+  }
+
+#ifdef MOZ_LOGGING
+  if (mTargetDragDataLen && mTargetDragData) {
+    LOGDRAGSERVICE("  %s got from system", flavor.get());
+  } else {
+    LOGDRAGSERVICE("  %s failed to get from system", flavor.get());
+  }
+#endif
+}
+
+void nsDragService::TargetResetData(void) {
+  mTargetDragDataReceived = false;
+  // make sure to free old data if we have to
+  g_free(mTargetDragData);
+  mTargetDragData = 0;
+  mTargetDragDataLen = 0;
+}
+
+static void TargetArrayAddTarget(nsTArray<GtkTargetEntry*>& aTargetArray,
+                                 const char* aTarget) {
+  GtkTargetEntry* target = (GtkTargetEntry*)g_malloc(sizeof(GtkTargetEntry));
+  target->target = g_strdup(aTarget);
+  target->flags = 0;
+  aTargetArray.AppendElement(target);
+  LOGDRAGSERVICESTATIC("adding target %s\n", aTarget);
+}
+
+static bool CanExportAsURLTarget(const char16_t* aURLData, uint32_t aURLLen) {
+  for (const nsLiteralString& disallowed : kDisallowedExportedSchemes) {
+    auto len = disallowed.AsString().Length();
+    if (len < aURLLen) {
+      if (!memcmp(disallowed.get(), aURLData,
+                  /* len is char16_t char count */ len * 2)) {
+        LOGDRAGSERVICESTATIC("rejected URL scheme %s\n",
+                             NS_ConvertUTF16toUTF8(disallowed).get());
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+GtkTargetList* nsDragService::GetSourceList(void) {
+  if (!mSourceDataItems) {
+    return nullptr;
+  }
+
+  nsTArray<GtkTargetEntry*> targetArray;
+  GtkTargetEntry* targets;
+  GtkTargetList* targetList = 0;
+  uint32_t targetCount = 0;
+  unsigned int numDragItems = 0;
+
+  mSourceDataItems->GetLength(&numDragItems);
+  LOGDRAGSERVICE("  numDragItems = %d", numDragItems);
+
+  // Check to see if we're dragging > 1 item.
+  if (numDragItems > 1) {
+    // as the Xdnd protocol only supports a single item (or is it just
+    // gtk's implementation?), we don't advertise all flavours listed
+    // in the nsITransferable.
+
+    // the application/x-moz-internal-item-list format, which preserves
+    // all information for drags within the same mozilla instance.
+    TargetArrayAddTarget(targetArray, gMimeListType);
+
+    // check what flavours are supported so we can decide what other
+    // targets to advertise.
+    nsCOMPtr<nsITransferable> currItem = do_QueryElementAt(mSourceDataItems, 0);
+
+    if (currItem) {
+      nsTArray<nsCString> flavors;
+      currItem->FlavorsTransferableCanExport(flavors);
+      for (uint32_t i = 0; i < flavors.Length(); ++i) {
+        // check if text/x-moz-url is supported.
+        // If so, advertise
+        // text/uri-list.
+        if (flavors[i].EqualsLiteral(kURLMime)) {
+          TargetArrayAddTarget(targetArray, gTextUriListType);
+          break;
+        }
+      }
+    }  // if item is a transferable
+  } else if (numDragItems == 1) {
+    nsCOMPtr<nsITransferable> currItem = do_QueryElementAt(mSourceDataItems, 0);
+    if (currItem) {
+      nsTArray<nsCString> flavors;
+      currItem->FlavorsTransferableCanExport(flavors);
+      for (uint32_t i = 0; i < flavors.Length(); ++i) {
+        nsCString& flavorStr = flavors[i];
+
+        TargetArrayAddTarget(targetArray, flavorStr.get());
+
+        // If there is a file, add the text/uri-list type.
+        if (flavorStr.EqualsLiteral(kFileMime)) {
+          TargetArrayAddTarget(targetArray, gTextUriListType);
+        }
+        // Check to see if this is text/unicode.
+        // If it is, add text/plain
+        // since we automatically support text/plain
+        // if we support text/unicode.
+        else if (flavorStr.EqualsLiteral(kUnicodeMime)) {
+          TargetArrayAddTarget(targetArray, gTextPlainUTF8Type);
+          TargetArrayAddTarget(targetArray, kTextMime);
+        }
+        // Check to see if this is the x-moz-url type.
+        // If it is, add _NETSCAPE_URL
+        // this is a type used by everybody.
+        else if (flavorStr.EqualsLiteral(kURLMime)) {
+          nsCOMPtr<nsISupports> data;
+          if (NS_SUCCEEDED(currItem->GetTransferData(flavorStr.get(),
+                                                     getter_AddRefs(data)))) {
+            void* tmpData = nullptr;
+            uint32_t tmpDataLen = 0;
+            nsPrimitiveHelpers::CreateDataFromPrimitive(
+                nsDependentCString(flavorStr.get()), data, &tmpData,
+                &tmpDataLen);
+            if (tmpData) {
+              if (CanExportAsURLTarget(reinterpret_cast<char16_t*>(tmpData),
+                                       tmpDataLen / 2)) {
+                TargetArrayAddTarget(targetArray, gMozUrlType);
+              }
+              free(tmpData);
+            }
+          }
+        }
+        // check if application/x-moz-file-promise url is supported.
+        // If so, advertise text/uri-list.
+        else if (flavorStr.EqualsLiteral(kFilePromiseURLMime)) {
+          TargetArrayAddTarget(targetArray, gTextUriListType);
+        }
+        // XdndDirectSave, use on X.org only.
+        else if (widget::GdkIsX11Display() && !widget::IsXWaylandProtocol() &&
+                 flavorStr.EqualsLiteral(kFilePromiseMime)) {
+          TargetArrayAddTarget(targetArray, gXdndDirectSaveType);
+        }
+        // kNativeImageMime
+        else if (flavorStr.EqualsLiteral(kNativeImageMime)) {
+          TargetArrayAddTarget(targetArray, kPNGImageMime);
+          TargetArrayAddTarget(targetArray, kJPEGImageMime);
+          TargetArrayAddTarget(targetArray, kJPGImageMime);
+          TargetArrayAddTarget(targetArray, kGIFImageMime);
+        }
+      }
+    }
+  }
+
+  // get all the elements that we created.
+  targetCount = targetArray.Length();
+  if (targetCount) {
+    // allocate space to create the list of valid targets
+    targets = (GtkTargetEntry*)g_malloc(sizeof(GtkTargetEntry) * targetCount);
+    uint32_t targetIndex;
+    for (targetIndex = 0; targetIndex < targetCount; ++targetIndex) {
+      GtkTargetEntry* disEntry = targetArray.ElementAt(targetIndex);
+      // this is a string reference but it will be freed later.
+      targets[targetIndex].target = disEntry->target;
+      targets[targetIndex].flags = disEntry->flags;
+      targets[targetIndex].info = 0;
+    }
+    targetList = gtk_target_list_new(targets, targetCount);
+    // clean up the target list
+    for (uint32_t cleanIndex = 0; cleanIndex < targetCount; ++cleanIndex) {
+      GtkTargetEntry* thisTarget = targetArray.ElementAt(cleanIndex);
+      g_free(thisTarget->target);
+      g_free(thisTarget);
+    }
+    g_free(targets);
+  } else {
+    // We need to create a dummy target list to be able initialize dnd.
+    targetList = gtk_target_list_new(nullptr, 0);
+  }
+  return targetList;
+}
+
+void nsDragService::SourceEndDragSession(GdkDragContext* aContext,
+                                         gint aResult) {
+  LOGDRAGSERVICE("SourceEndDragSession(%p) result %s\n", aContext,
+                 kGtkDragResults[aResult]);
+
+  // this just releases the list of data items that we provide
+  mSourceDataItems = nullptr;
+
+  // Remove this property, if it exists, to satisfy the Direct Save Protocol.
+  GdkAtom property = gdk_atom_intern(gXdndDirectSaveType, FALSE);
+  gdk_property_delete(gdk_drag_context_get_source_window(aContext), property);
+
+  if (!mDoingDrag || mScheduledTask == eDragTaskSourceEnd)
+    // EndDragSession() was already called on drop
+    // or SourceEndDragSession on drag-failed
+    return;
+
+  if (mEndDragPoint.x < 0) {
+    // We don't have a drag end point, so guess
+    gint x, y;
+    GdkDisplay* display = gdk_display_get_default();
+    GdkScreen* screen = gdk_display_get_default_screen(display);
+    GtkWindow* window = GetGtkWindow(mSourceDocument);
+    GdkWindow* gdkWindow = window ? gtk_widget_get_window(GTK_WIDGET(window))
+                                  : gdk_screen_get_root_window(screen);
+    gdk_window_get_device_position(
+        gdkWindow, gdk_drag_context_get_device(aContext), &x, &y, nullptr);
+    gint scale = gdk_window_get_scale_factor(gdkWindow);
+    SetDragEndPoint(LayoutDeviceIntPoint(x * scale, y * scale));
+    LOGDRAGSERVICE("  guess drag end point %d %d\n", x * scale, y * scale);
+  }
+
+  // Either the drag was aborted or the drop occurred outside the app.
+  // The dropEffect of mDataTransfer is not updated for motion outside the
+  // app, but is needed for the dragend event, so set it now.
+
+  uint32_t dropEffect;
+
+  if (aResult == GTK_DRAG_RESULT_SUCCESS) {
+    LOGDRAGSERVICE("  drop is accepted");
+    // With GTK+ versions 2.10.x and prior the drag may have been
+    // cancelled (but no drag-failed signal would have been sent).
+    // aContext->dest_window will be non-nullptr only if the drop was
+    // sent.
+    GdkDragAction action = gdk_drag_context_get_dest_window(aContext)
+                               ? gdk_drag_context_get_actions(aContext)
+                               : (GdkDragAction)0;
+
+    // Only one bit of action should be set, but, just in case someone
+    // does something funny, erring away from MOVE, and not recording
+    // unusual action combinations as NONE.
+    if (!action) {
+      LOGDRAGSERVICE("  drop action is none");
+      dropEffect = DRAGDROP_ACTION_NONE;
+    } else if (action & GDK_ACTION_COPY) {
+      LOGDRAGSERVICE("  drop action is copy");
+      dropEffect = DRAGDROP_ACTION_COPY;
+    } else if (action & GDK_ACTION_LINK) {
+      LOGDRAGSERVICE("  drop action is link");
+      dropEffect = DRAGDROP_ACTION_LINK;
+    } else if (action & GDK_ACTION_MOVE) {
+      LOGDRAGSERVICE("  drop action is move");
+      dropEffect = DRAGDROP_ACTION_MOVE;
+    } else {
+      LOGDRAGSERVICE("  drop action is copy");
+      dropEffect = DRAGDROP_ACTION_COPY;
+    }
+  } else {
+    LOGDRAGSERVICE("  drop action is none");
+    dropEffect = DRAGDROP_ACTION_NONE;
+    if (aResult != GTK_DRAG_RESULT_NO_TARGET) {
+      LOGDRAGSERVICE("  drop is user chancelled\n");
+      mUserCancelled = true;
+    }
+  }
+
+  if (mDataTransfer) {
+    mDataTransfer->SetDropEffectInt(dropEffect);
+  }
+
+  // Schedule the appropriate drag end dom events.
+  Schedule(eDragTaskSourceEnd, nullptr, nullptr, LayoutDeviceIntPoint(), 0);
+}
+
+static nsresult GetDownloadDetails(nsITransferable* aTransferable,
+                                   nsIURI** aSourceURI, nsAString& aFilename) {
+  *aSourceURI = nullptr;
+  MOZ_ASSERT(aTransferable != nullptr, "aTransferable must not be null");
+
+  // get the URI from the kFilePromiseURLMime flavor
+  nsCOMPtr<nsISupports> urlPrimitive;
+  nsresult rv = aTransferable->GetTransferData(kFilePromiseURLMime,
+                                               getter_AddRefs(urlPrimitive));
+  if (NS_FAILED(rv)) {
+    return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<nsISupportsString> srcUrlPrimitive = do_QueryInterface(urlPrimitive);
+  if (!srcUrlPrimitive) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsAutoString srcUri;
+  srcUrlPrimitive->GetData(srcUri);
+  if (srcUri.IsEmpty()) {
+    return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<nsIURI> sourceURI;
+  NS_NewURI(getter_AddRefs(sourceURI), srcUri);
+
+  nsAutoString srcFileName;
+  nsCOMPtr<nsISupports> fileNamePrimitive;
+  rv = aTransferable->GetTransferData(kFilePromiseDestFilename,
+                                      getter_AddRefs(fileNamePrimitive));
+  if (NS_FAILED(rv)) {
+    return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<nsISupportsString> srcFileNamePrimitive =
+      do_QueryInterface(fileNamePrimitive);
+  if (srcFileNamePrimitive) {
+    srcFileNamePrimitive->GetData(srcFileName);
+  } else {
+    nsCOMPtr<nsIURL> sourceURL = do_QueryInterface(sourceURI);
+    if (!sourceURL) {
+      return NS_ERROR_FAILURE;
+    }
+    nsAutoCString urlFileName;
+    sourceURL->GetFileName(urlFileName);
+    NS_UnescapeURL(urlFileName);
+    CopyUTF8toUTF16(urlFileName, srcFileName);
+  }
+  if (srcFileName.IsEmpty()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  sourceURI.swap(*aSourceURI);
+  aFilename = srcFileName;
+  return NS_OK;
+}
+
+// See nsContentAreaDragDropDataProvider::GetFlavorData() for reference.
+nsresult nsDragService::CreateTempFile(nsITransferable* aItem,
+                                       nsACString& aURI) {
+  LOGDRAGSERVICE("nsDragService::CreateTempFile()");
+
+  nsCOMPtr<nsIFile> tmpDir;
+  nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmpDir));
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to get temp directory\n");
+    return rv;
+  }
+
+  nsCOMPtr<nsIInputStream> inputStream;
+  nsCOMPtr<nsIChannel> channel;
+
+  // extract the file name and source uri of the promise-file data
+  nsAutoString wideFileName;
+  nsCOMPtr<nsIURI> sourceURI;
+  rv = GetDownloadDetails(aItem, getter_AddRefs(sourceURI), wideFileName);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE(
+        "  Failed to extract file name and source uri from download url");
+    return rv;
+  }
+
+  // Check if the file is already stored at /tmp.
+  // It happens when drop destination is changed and SourceDataGet() is caled
+  // more than once.
+  nsAutoCString fileName;
+  CopyUTF16toUTF8(wideFileName, fileName);
+  auto fileLen = fileName.Length();
+  for (const auto& url : mTempFileUrls) {
+    auto URLLen = url.Length();
+    if (URLLen > fileLen &&
+        fileName.Equals(nsDependentCString(url, URLLen - fileLen))) {
+      aURI = url;
+      LOGDRAGSERVICE("  recycle file %s", PromiseFlatCString(aURI).get());
+      return NS_OK;
+    }
+  }
+
+  // create and open channel for source uri
+  nsCOMPtr<nsIPrincipal> principal = aItem->GetRequestingPrincipal();
+  nsContentPolicyType contentPolicyType = aItem->GetContentPolicyType();
+  nsCOMPtr<nsICookieJarSettings> cookieJarSettings =
+      aItem->GetCookieJarSettings();
+  rv = NS_NewChannel(getter_AddRefs(channel), sourceURI, principal,
+                     nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+                     contentPolicyType, cookieJarSettings);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to create new channel for source uri");
+    return rv;
+  }
+
+  rv = channel->Open(getter_AddRefs(inputStream));
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to open channel for source uri");
+    return rv;
+  }
+
+  // build the file:///tmp/dnd_file URL
+  tmpDir->Append(NS_LITERAL_STRING_FROM_CSTRING("dnd_file"));
+  rv = tmpDir->CreateUnique(nsIFile::DIRECTORY_TYPE, 0700);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed create tmp dir");
+    return rv;
+  }
+
+  // store a copy of that temporary directory so we can
+  // clean them up when nsDragService is destructed
+  nsCOMPtr<nsIFile> tempFile;
+  tmpDir->Clone(getter_AddRefs(tempFile));
+  mTemporaryFiles.AppendObject(tempFile);
+  if (mTempFileTimerID) {
+    g_source_remove(mTempFileTimerID);
+    mTempFileTimerID = 0;
+  }
+
+  // extend file:///tmp/dnd_file/<filename> URL
+  tmpDir->Append(wideFileName);
+
+  nsCOMPtr<nsIOutputStream> outputStream;
+  rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), tmpDir);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to open output stream for temporary file");
+    return rv;
+  }
+
+  char buffer[8192];
+  uint32_t readCount = 0;
+  uint32_t writeCount = 0;
+  while (1) {
+    rv = inputStream->Read(buffer, sizeof(buffer), &readCount);
+    if (NS_FAILED(rv)) {
+      LOGDRAGSERVICE("  Failed to read data from source uri");
+      return rv;
+    }
+
+    if (readCount == 0) break;
+
+    rv = outputStream->Write(buffer, readCount, &writeCount);
+    if (NS_FAILED(rv)) {
+      LOGDRAGSERVICE("  Failed to write data to temporary file");
+      return rv;
+    }
+  }
+
+  inputStream->Close();
+  rv = outputStream->Close();
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to write data to temporary file");
+    return rv;
+  }
+
+  nsCOMPtr<nsIURI> uri;
+  rv = NS_NewFileURI(getter_AddRefs(uri), tmpDir);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to get file URI");
+    return rv;
+  }
+  nsCOMPtr<nsIURL> fileURL(do_QueryInterface(uri));
+  if (!fileURL) {
+    LOGDRAGSERVICE("  Failed to query file interface");
+    return NS_ERROR_FAILURE;
+  }
+  rv = fileURL->GetSpec(aURI);
+  if (NS_FAILED(rv)) {
+    LOGDRAGSERVICE("  Failed to get filepath");
+    return rv;
+  }
+
+  // store url of temporary file
+  mTempFileUrls.AppendElement()->Assign(aURI);
+  LOGDRAGSERVICE("  storing tmp file as %s", PromiseFlatCString(aURI).get());
+  return NS_OK;
+}
+
+bool nsDragService::SourceDataAppendURLFileItem(nsACString& aURI,
+                                                nsITransferable* aItem) {
+  // If there is a file available, create a URI from the file.
+  nsCOMPtr<nsISupports> data;
+  nsresult rv = aItem->GetTransferData(kFileMime, getter_AddRefs(data));
+  NS_ENSURE_SUCCESS(rv, false);
+  if (nsCOMPtr<nsIFile> file = do_QueryInterface(data)) {
+    nsCOMPtr<nsIURI> fileURI;
+    NS_NewFileURI(getter_AddRefs(fileURI), file);
+    if (fileURI) {
+      fileURI->GetSpec(aURI);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool nsDragService::SourceDataAppendURLItem(nsITransferable* aItem,
+                                            bool aExternalDrop,
+                                            nsACString& aURI) {
+  nsCOMPtr<nsISupports> data;
+  nsresult rv = aItem->GetTransferData(kURLMime, getter_AddRefs(data));
+  if (NS_FAILED(rv)) {
+    return SourceDataAppendURLFileItem(aURI, aItem);
+  }
+
+  nsCOMPtr<nsISupportsString> string = do_QueryInterface(data);
+  if (!string) {
+    return false;
+  }
+
+  nsAutoString text;
+  string->GetData(text);
+  if (!aExternalDrop || CanExportAsURLTarget(text.get(), text.Length())) {
+    AppendUTF16toUTF8(text, aURI);
+    return true;
+  }
+
+  // We're dropping to another application and the URL can't be exported
+  // as it's internal one (mailbox:// etc.)
+  // Try to get file target directly.
+  if (SourceDataAppendURLFileItem(aURI, aItem)) {
+    return true;
+  }
+
+  // We can't get the file directly so try to download it and save to tmp.
+  // The desktop or file manager expects for drags of promise-file data
+  // the text/uri-list flavor set to a temporary file that contains the
+  // promise-file data.
+  // We open a stream on the <protocol>:// url here and save the content
+  // to file:///tmp/dnd_file/<filename> and pass this url
+  // as text/uri-list flavor.
+
+  // check whether transferable contains FilePromiseUrl flavor...
+  nsCOMPtr<nsISupports> promiseData;
+  rv = aItem->GetTransferData(kFilePromiseURLMime, getter_AddRefs(promiseData));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  // ... if so, create a temporary file and pass its url
+  return NS_SUCCEEDED(CreateTempFile(aItem, aURI));
+}
+
+void nsDragService::SourceDataGetUriList(GdkDragContext* aContext,
+                                         GtkSelectionData* aSelectionData,
+                                         uint32_t aDragItems) {
+  // Check if we're transfering data to another application.
+  // gdk_drag_context_get_dest_window() on X11 returns GdkWindow even for
+  // different application so use nsWindow::GetWindow() to check if that's
+  // our window.
+  const bool isExternalDrop =
+      widget::GdkIsX11Display()
+          ? !nsWindow::GetWindow(gdk_drag_context_get_dest_window(aContext))
+          : !gdk_drag_context_get_dest_window(aContext);
+
+  LOGDRAGSERVICE("nsDragService::SourceDataGetUriLists() len %d external %d",
+                 aDragItems, isExternalDrop);
+
+  // Disable processing of native events until we store all files to /tmp.
+  // Otherwise user can quit drop before we have all files saved
+  // and that cancels whole D&D.
+  AutoSuspendNativeEvents suspend;
+
+  nsAutoCString uriList;
+  for (uint32_t i = 0; i < aDragItems; i++) {
+    nsCOMPtr<nsITransferable> item = do_QueryElementAt(mSourceDataItems, i);
+    if (!item) {
+      continue;
+    }
+    nsAutoCString uri;
+    if (!SourceDataAppendURLItem(item, isExternalDrop, uri)) {
+      continue;
+    }
+    // text/x-moz-url is of form url + "\n" + title.
+    // We just want the url.
+    int32_t separatorPos = uri.FindChar(u'\n');
+    if (separatorPos >= 0) {
+      uri.Truncate(separatorPos);
+    }
+    uriList.Append(uri);
+    uriList.AppendLiteral("\r\n");
+  }
+
+  LOGDRAGSERVICE("URI list\n%s", uriList.get());
+  GdkAtom target = gtk_selection_data_get_target(aSelectionData);
+  gtk_selection_data_set(aSelectionData, target, 8, (guchar*)uriList.get(),
+                         uriList.Length());
+}
+
+void nsDragService::SourceDataGetImage(nsITransferable* aItem,
+                                       GtkSelectionData* aSelectionData) {
+  LOGDRAGSERVICE("nsDragService::SourceDataGetImage()");
+
+  nsresult rv;
+  nsCOMPtr<nsISupports> data;
+  rv = aItem->GetTransferData(kNativeImageMime, getter_AddRefs(data));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  LOGDRAGSERVICE("  posting image\n");
+  nsCOMPtr<imgIContainer> image = do_QueryInterface(data);
+  if (!image) {
+    LOGDRAGSERVICE("  do_QueryInterface failed\n");
+    return;
+  }
+  RefPtr<GdkPixbuf> pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
+  if (!pixbuf) {
+    LOGDRAGSERVICE("  ImageToPixbuf failed\n");
+    return;
+  }
+  gtk_selection_data_set_pixbuf(aSelectionData, pixbuf);
+  LOGDRAGSERVICE("  image data set\n");
+  return;
+}
+
+void nsDragService::SourceDataGetXDND(nsITransferable* aItem,
+                                      GdkDragContext* aContext,
+                                      GtkSelectionData* aSelectionData) {
+  LOGDRAGSERVICE("nsDragService::SourceDataGetXDND");
+
+  // Indicate failure by default.
+  GdkAtom target = gtk_selection_data_get_target(aSelectionData);
+  gtk_selection_data_set(aSelectionData, target, 8, (guchar*)"E", 1);
+
+  GdkAtom property = gdk_atom_intern(gXdndDirectSaveType, FALSE);
+  GdkAtom type = gdk_atom_intern(kTextMime, FALSE);
+
+  GdkWindow* srcWindow = gdk_drag_context_get_source_window(aContext);
+  if (!srcWindow) {
+    LOGDRAGSERVICE("  failed to get source GdkWindow!");
+    return;
+  }
+
+  // Ensure null termination.
+  nsAutoCString data;
+  {
+    GUniquePtr<guchar> gdata;
+    gint length = 0;
+    if (!gdk_property_get(srcWindow, property, type, 0, INT32_MAX, FALSE,
+                          nullptr, nullptr, &length, getter_Transfers(gdata))) {
+      LOGDRAGSERVICE("  failed to get gXdndDirectSaveType GdkWindow property.");
+      return;
+    }
+    data.Assign(nsDependentCSubstring((const char*)gdata.get(), length));
+  }
+
+  GUniquePtr<char> hostname;
+  GUniquePtr<char> fullpath(
+      g_filename_from_uri(data.get(), getter_Transfers(hostname), nullptr));
+  if (!fullpath) {
+    LOGDRAGSERVICE("  failed to get file from uri.");
+    return;
+  }
+
+  // If there is no hostname in the URI, NULL will be stored.
+  // We should not accept uris with from a different host.
+  if (hostname) {
+    nsCOMPtr<nsIPropertyBag2> infoService =
+        do_GetService(NS_SYSTEMINFO_CONTRACTID);
+    if (!infoService) {
+      return;
+    }
+    nsAutoCString host;
+    if (NS_SUCCEEDED(infoService->GetPropertyAsACString(u"host"_ns, host))) {
+      if (!host.Equals(hostname.get())) {
+        LOGDRAGSERVICE("  ignored drag because of different host.");
+        // Special error code "F" for this case.
+        gtk_selection_data_set(aSelectionData, target, 8, (guchar*)"F", 1);
+        return;
+      }
+    }
+  }
+
+  LOGDRAGSERVICE("  XdndDirectSave filepath is %s", fullpath.get());
+
+  nsCOMPtr<nsIFile> file;
+  if (NS_FAILED(NS_NewNativeLocalFile(nsDependentCString(fullpath.get()), false,
+                                      getter_AddRefs(file)))) {
+    LOGDRAGSERVICE("  failed to get local file");
+    return;
+  }
+
+  // We have to split the path into a directory and filename,
+  // because our internal file-promise API is based on these.
+  nsCOMPtr<nsIFile> directory;
+  file->GetParent(getter_AddRefs(directory));
+
+  aItem->SetTransferData(kFilePromiseDirectoryMime, directory);
+
+  nsCOMPtr<nsISupportsString> filenamePrimitive =
+      do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID);
+  if (!filenamePrimitive) {
+    return;
+  }
+
+  nsAutoString leafName;
+  file->GetLeafName(leafName);
+  filenamePrimitive->SetData(leafName);
+
+  aItem->SetTransferData(kFilePromiseDestFilename, filenamePrimitive);
+
+  nsCOMPtr<nsISupports> promiseData;
+  nsresult rv =
+      aItem->GetTransferData(kFilePromiseMime, getter_AddRefs(promiseData));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // Indicate success.
+  gtk_selection_data_set(aSelectionData, target, 8, (guchar*)"S", 1);
+  return;
+}
+
+bool nsDragService::SourceDataGetText(nsITransferable* aItem,
+                                      const nsACString& aMIMEType,
+                                      bool aNeedToDoConversionToPlainText,
+                                      GtkSelectionData* aSelectionData) {
+  LOGDRAGSERVICE("nsDragService::SourceDataGetPlain()");
+
+  nsresult rv;
+  nsCOMPtr<nsISupports> data;
+  rv = aItem->GetTransferData(PromiseFlatCString(aMIMEType).get(),
+                              getter_AddRefs(data));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  void* tmpData = nullptr;
+  uint32_t tmpDataLen = 0;
+
+  nsPrimitiveHelpers::CreateDataFromPrimitive(aMIMEType, data, &tmpData,
+                                              &tmpDataLen);
+  // if required, do the extra work to convert unicode to plain
+  // text and replace the output values with the plain text.
+  if (aNeedToDoConversionToPlainText) {
+    char* plainTextData = nullptr;
+    char16_t* castedUnicode = reinterpret_cast<char16_t*>(tmpData);
+    uint32_t plainTextLen = 0;
+    UTF16ToNewUTF8(castedUnicode, tmpDataLen / 2, &plainTextData,
+                   &plainTextLen);
+    if (tmpData) {
+      // this was not allocated using glib
+      free(tmpData);
+      tmpData = plainTextData;
+      tmpDataLen = plainTextLen;
+    }
+  }
+  if (tmpData) {
+    // this copies the data
+    GdkAtom target = gtk_selection_data_get_target(aSelectionData);
+    gtk_selection_data_set(aSelectionData, target, 8, (guchar*)tmpData,
+                           tmpDataLen);
+    // this wasn't allocated with glib
+    free(tmpData);
+  }
+
+  return true;
+}
+
+// We're asked to get data from mSourceDataItems and pass it to
+// GtkSelectionData (Gtk D&D interface).
+// We need to check mSourceDataItems data type and try to convert it
+// to data type accepted by Gtk.
+void nsDragService::SourceDataGet(GtkWidget* aWidget, GdkDragContext* aContext,
+                                  GtkSelectionData* aSelectionData,
+                                  guint32 aTime) {
+  LOGDRAGSERVICE("nsDragService::SourceDataGet(%p)", aContext);
+
+  GdkAtom target = gtk_selection_data_get_target(aSelectionData);
+  GUniquePtr<gchar> requestedTypeName(gdk_atom_name(target));
+  if (!requestedTypeName) {
+    LOGDRAGSERVICE("  failed to get atom name.\n");
+    return;
+  }
+
+  LOGDRAGSERVICE("  Gtk asks us for %s data type\n", requestedTypeName.get());
+  // check to make sure that we have data items to return.
+  if (!mSourceDataItems) {
+    LOGDRAGSERVICE("  Failed to get our data items\n");
+    return;
+  }
+
+  uint32_t dragItems;
+  mSourceDataItems->GetLength(&dragItems);
+  LOGDRAGSERVICE("  source data items %d", dragItems);
+
+  nsDependentCString mimeFlavor(requestedTypeName.get());
+  if (mimeFlavor.EqualsLiteral(gTextUriListType)) {
+    SourceDataGetUriList(aContext, aSelectionData, dragItems);
+    return;
+  }
+
+#ifdef MOZ_LOGGING
+  if (dragItems > 1) {
+    LOGDRAGSERVICE(
+        "  There are %d data items but we're asked for %s MIME type. Only "
+        "first data element can be transfered!",
+        dragItems, mimeFlavor.get());
+  }
+#endif
+
+  nsCOMPtr<nsITransferable> item = do_QueryElementAt(mSourceDataItems, 0);
+  if (!item) {
+    LOGDRAGSERVICE("  Failed to get SourceDataItems!");
+    return;
+  }
+
+  if (mimeFlavor.EqualsLiteral(kTextMime) ||
+      mimeFlavor.EqualsLiteral(gTextPlainUTF8Type)) {
+    SourceDataGetText(item, nsDependentCString(kUnicodeMime),
+                      /* aNeedToDoConversionToPlainText */ true,
+                      aSelectionData);
+    // no fallback for text mime types
+    return;
+  }
+  // Someone is asking for the special Direct Save Protocol type.
+  else if (mimeFlavor.EqualsLiteral(gXdndDirectSaveType)) {
+    SourceDataGetXDND(item, aContext, aSelectionData);
+    // no fallback for XDND mime types
+    return;
+  } else if (mimeFlavor.EqualsLiteral(kPNGImageMime) ||
+             mimeFlavor.EqualsLiteral(kJPEGImageMime) ||
+             mimeFlavor.EqualsLiteral(kJPGImageMime) ||
+             mimeFlavor.EqualsLiteral(kGIFImageMime)) {
+    // no fallback for image mime types
+    SourceDataGetImage(item, aSelectionData);
+    return;
+  } else if (mimeFlavor.EqualsLiteral(gMozUrlType)) {
+    // Someone was asking for _NETSCAPE_URL. We need to get it from
+    // transferable as x-moz-url and convert it to plain text.
+    // No need to check
+    if (SourceDataGetText(item, nsDependentCString(kURLMime),
+                          /* aNeedToDoConversionToPlainText */ true,
+                          aSelectionData)) {
+      return;
+    }
+  }
+  // Just try to get and set whatever we're asked for.
+  SourceDataGetText(item, mimeFlavor,
+                    /* aNeedToDoConversionToPlainText */ false, aSelectionData);
+}
+
+void nsDragService::SourceBeginDrag(GdkDragContext* aContext) {
+  LOGDRAGSERVICE("nsDragService::SourceBeginDrag(%p)\n", aContext);
+
+  nsCOMPtr<nsITransferable> transferable =
+      do_QueryElementAt(mSourceDataItems, 0);
+  if (!transferable) return;
+
+  nsTArray<nsCString> flavors;
+  nsresult rv = transferable->FlavorsTransferableCanImport(flavors);
+  NS_ENSURE_SUCCESS(rv, );
+
+  for (uint32_t i = 0; i < flavors.Length(); ++i) {
+    if (flavors[i].EqualsLiteral(kFilePromiseDestFilename)) {
+      nsCOMPtr<nsISupports> data;
+      rv = transferable->GetTransferData(kFilePromiseDestFilename,
+                                         getter_AddRefs(data));
+      if (NS_FAILED(rv)) {
+        LOGDRAGSERVICE("  transferable doesn't contain '%s",
+                       kFilePromiseDestFilename);
+        return;
+      }
+
+      nsCOMPtr<nsISupportsString> fileName = do_QueryInterface(data);
+      if (!fileName) {
+        LOGDRAGSERVICE("  failed to get file name");
+        return;
+      }
+
+      nsAutoString fileNameStr;
+      fileName->GetData(fileNameStr);
+
+      nsCString fileNameCStr;
+      CopyUTF16toUTF8(fileNameStr, fileNameCStr);
+
+      GdkAtom property = gdk_atom_intern(gXdndDirectSaveType, FALSE);
+      GdkAtom type = gdk_atom_intern(kTextMime, FALSE);
+
+      gdk_property_change(gdk_drag_context_get_source_window(aContext),
+                          property, type, 8, GDK_PROP_MODE_REPLACE,
+                          (const guchar*)fileNameCStr.get(),
+                          fileNameCStr.Length());
+      break;
+    }
+  }
+}
+
+void nsDragService::SetDragIcon(GdkDragContext* aContext) {
+  if (!mHasImage && !mSelection) return;
+
+  LOGDRAGSERVICE("nsDragService::SetDragIcon(%p)", aContext);
+
+  LayoutDeviceIntRect dragRect;
+  nsPresContext* pc;
+  RefPtr<SourceSurface> surface;
+  DrawDrag(mSourceNode, mRegion, mScreenPosition, &dragRect, &surface, &pc);
+  if (!pc) {
+    LOGDRAGSERVICE("  PresContext is missing!");
+    return;
+  }
+
+  const auto screenPoint =
+      LayoutDeviceIntPoint::Round(mScreenPosition * pc->CSSToDevPixelScale());
+  int32_t offsetX = screenPoint.x - dragRect.x;
+  int32_t offsetY = screenPoint.y - dragRect.y;
+
+  // If a popup is set as the drag image, use its widget. Otherwise, use
+  // the surface that DrawDrag created.
+  //
+  // XXX: Disable drag popups on GTK 3.19.4 and above: see bug 1264454.
+  //      Fix this once a new GTK version ships that does not destroy our
+  //      widget in gtk_drag_set_icon_widget.
+  //      This is fixed in GTK 3.24
+  //      by
+  //      https://gitlab.gnome.org/GNOME/gtk/-/commit/c27c4e2048acb630feb24c31288f802345e99f4c
+  bool gtk_drag_set_icon_widget_is_working =
+      gtk_check_version(3, 19, 4) != nullptr ||
+      gtk_check_version(3, 24, 0) == nullptr;
+  if (mDragPopup && gtk_drag_set_icon_widget_is_working) {
+    GtkWidget* gtkWidget = nullptr;
+    nsIFrame* frame = mDragPopup->GetPrimaryFrame();
+    if (frame) {
+      // DrawDrag ensured that this is a popup frame.
+      nsCOMPtr<nsIWidget> widget = frame->GetNearestWidget();
+      if (widget) {
+        gtkWidget = (GtkWidget*)widget->GetNativeData(NS_NATIVE_SHELLWIDGET);
+        if (gtkWidget) {
+          // When mDragPopup has a parent it's already attached to D&D context.
+          // That may happens when D&D operation is aborted but not finished
+          // on Gtk side yet so let's remove it now.
+          if (GtkWidget* parent = gtk_widget_get_parent(gtkWidget)) {
+            gtk_container_remove(GTK_CONTAINER(parent), gtkWidget);
+          }
+          LOGDRAGSERVICE("  set drag popup [%p]", widget.get());
+          OpenDragPopup();
+          gtk_drag_set_icon_widget(aContext, gtkWidget, offsetX, offsetY);
+          return;
+        } else {
+          LOGDRAGSERVICE("  NS_NATIVE_SHELLWIDGET is missing!");
+        }
+      } else {
+        LOGDRAGSERVICE("  NearestWidget is missing!");
+      }
+    } else {
+      LOGDRAGSERVICE("  PrimaryFrame is missing!");
+    }
+  }
+
+  if (surface) {
+    LOGDRAGSERVICE("  We have a surface");
+    if (!SetAlphaPixmap(surface, aContext, offsetX, offsetY, dragRect)) {
+      RefPtr<GdkPixbuf> dragPixbuf = nsImageToPixbuf::SourceSurfaceToPixbuf(
+          surface, dragRect.width, dragRect.height);
+      if (dragPixbuf) {
+        LOGDRAGSERVICE("  set drag pixbuf");
+        gtk_drag_set_icon_pixbuf(aContext, dragPixbuf, offsetX, offsetY);
+      } else {
+        LOGDRAGSERVICE("  SourceSurfaceToPixbuf failed!");
+      }
+    }
+  } else {
+    LOGDRAGSERVICE("  Surface is missing!");
+  }
+}
+
+static void invisibleSourceDragBegin(GtkWidget* aWidget,
+                                     GdkDragContext* aContext, gpointer aData) {
+  LOGDRAGSERVICESTATIC("invisibleSourceDragBegin (%p)", aContext);
+  nsDragService* dragService = (nsDragService*)aData;
+
+  dragService->SourceBeginDrag(aContext);
+  dragService->SetDragIcon(aContext);
+}
+
+static void invisibleSourceDragDataGet(GtkWidget* aWidget,
+                                       GdkDragContext* aContext,
+                                       GtkSelectionData* aSelectionData,
+                                       guint aInfo, guint32 aTime,
+                                       gpointer aData) {
+  LOGDRAGSERVICESTATIC("invisibleSourceDragDataGet (%p)", aContext);
+  nsDragService* dragService = (nsDragService*)aData;
+  dragService->SourceDataGet(aWidget, aContext, aSelectionData, aTime);
+}
+
+static gboolean invisibleSourceDragFailed(GtkWidget* aWidget,
+                                          GdkDragContext* aContext,
+                                          gint aResult, gpointer aData) {
+#ifdef MOZ_WAYLAND
+  // Wayland and X11 uses different drag results here. When drag target is
+  // missing X11 passes GDK_DRAG_CANCEL_NO_TARGET
+  // (from gdk_dnd_handle_button_event()/gdkdnd-x11.c)
+  // as backend X11 has info about other application windows.
+  // Wayland does not have such info so it always passes
+  // GDK_DRAG_CANCEL_ERROR error code
+  // (see data_source_cancelled/gdkselection-wayland.c).
+  // Bug 1527976
+  if (widget::GdkIsWaylandDisplay() && aResult == GTK_DRAG_RESULT_ERROR) {
+    for (GList* tmp = gdk_drag_context_list_targets(aContext); tmp;
+         tmp = tmp->next) {
+      GdkAtom atom = GDK_POINTER_TO_ATOM(tmp->data);
+      GUniquePtr<gchar> name(gdk_atom_name(atom));
+      if (name && !strcmp(name.get(), gTabDropType)) {
+        aResult = GTK_DRAG_RESULT_NO_TARGET;
+        LOGDRAGSERVICESTATIC("invisibleSourceDragFailed(%p): Wayland tab drop",
+                             aContext);
+        break;
+      }
+    }
+  }
+#endif
+  LOGDRAGSERVICESTATIC("invisibleSourceDragFailed(%p) %s", aContext,
+                       kGtkDragResults[aResult]);
+  nsDragService* dragService = (nsDragService*)aData;
+  // End the drag session now (rather than waiting for the drag-end signal)
+  // so that operations performed on dropEffect == none can start immediately
+  // rather than waiting for the drag-failed animation to finish.
+  dragService->SourceEndDragSession(aContext, aResult);
+
+  // We should return TRUE to disable the drag-failed animation iff the
+  // source performed an operation when dropEffect was none, but the handler
+  // of the dragend DOM event doesn't provide this information.
+  return FALSE;
+}
+
+static void invisibleSourceDragEnd(GtkWidget* aWidget, GdkDragContext* aContext,
+                                   gpointer aData) {
+  LOGDRAGSERVICESTATIC("invisibleSourceDragEnd(%p)", aContext);
+  nsDragService* dragService = (nsDragService*)aData;
+
+  // The drag has ended.  Release the hostages!
+  dragService->SourceEndDragSession(aContext, GTK_DRAG_RESULT_SUCCESS);
+}
+
+// The following methods handle responding to GTK drag signals and
+// tracking state between these signals.
+//
+// In general, GTK does not expect us to run the event loop while handling its
+// drag signals, however our drag event handlers may run the
+// event loop, most often to fetch information about the drag data.
+//
+// GTK, for example, uses the return value from drag-motion signals to
+// determine whether drag-leave signals should be sent.  If an event loop is
+// run during drag-motion the XdndLeave message can get processed but when GTK
+// receives the message it does not yet know that it needs to send the
+// drag-leave signal to our widget.
+//
+// After a drag-drop signal, we need to reply with gtk_drag_finish().
+// However, gtk_drag_finish should happen after the drag-drop signal handler
+// returns so that when the Motif drag protocol is used, the
+// XmTRANSFER_SUCCESS during gtk_drag_finish is sent after the XmDROP_START
+// reply sent on return from the drag-drop signal handler.
+//
+// Similarly drag-end for a successful drag and drag-failed are not good
+// times to run a nested event loop as gtk_drag_drop_finished() and
+// gtk_drag_source_info_destroy() don't gtk_drag_clear_source_info() or remove
+// drop_timeout until after at least the first of these signals is sent.
+// Processing other events (e.g. a slow GDK_DROP_FINISHED reply, or the drop
+// timeout) could cause gtk_drag_drop_finished to be called again with the
+// same GtkDragSourceInfo, which won't like being destroyed twice.
+//
+// Therefore we reply to the signals immediately and schedule a task to
+// dispatch the Gecko events, which may run the event loop.
+//
+// Action in response to drag-leave signals is also delayed until the event
+// loop runs again so that we find out whether a drag-drop signal follows.
+//
+// A single task is scheduled to manage responses to all three GTK signals.
+// If further signals are received while the task is scheduled, the scheduled
+// response is updated, sometimes effectively compressing successive signals.
+//
+// No Gecko drag events are dispatched (during nested event loops) while other
+// Gecko drag events are in flight.  This helps event handlers that may not
+// expect nested events, while accessing an event's dataTransfer for example.
+
+gboolean nsDragService::ScheduleMotionEvent(nsWindow* aWindow,
+                                            GdkDragContext* aDragContext,
+                                            LayoutDeviceIntPoint aWindowPoint,
+                                            guint aTime) {
+  if (aDragContext && mScheduledTask == eDragTaskMotion) {
+    // The drag source has sent another motion message before we've
+    // replied to the previous.  That shouldn't happen with Xdnd.  The
+    // spec for Motif drags is less clear, but we'll just update the
+    // scheduled task with the new position reply only to the most
+    // recent message.
+    NS_WARNING("Drag Motion message received before previous reply was sent");
+  }
+
+  // Returning TRUE means we'll reply with a status message, unless we first
+  // get a leave.
+  return Schedule(eDragTaskMotion, aWindow, aDragContext, aWindowPoint, aTime);
+}
+
+void nsDragService::ScheduleLeaveEvent() {
+  // We don't know at this stage whether a drop signal will immediately
+  // follow.  If the drop signal gets sent it will happen before we return
+  // to the main loop and the scheduled leave task will be replaced.
+  if (!Schedule(eDragTaskLeave, nullptr, nullptr, LayoutDeviceIntPoint(), 0)) {
+    NS_WARNING("Drag leave after drop");
+  }
+}
+
+gboolean nsDragService::ScheduleDropEvent(nsWindow* aWindow,
+                                          GdkDragContext* aDragContext,
+                                          LayoutDeviceIntPoint aWindowPoint,
+                                          guint aTime) {
+  if (!Schedule(eDragTaskDrop, aWindow, aDragContext, aWindowPoint, aTime)) {
+    NS_WARNING("Additional drag drop ignored");
+    return FALSE;
+  }
+
+  SetDragEndPoint(aWindowPoint);
+
+  // We'll reply with gtk_drag_finish().
+  return TRUE;
+}
+
+#ifdef MOZ_LOGGING
+const char* nsDragService::GetDragServiceTaskName(DragTask aTask) {
+  static const char* taskNames[] = {"eDragTaskNone", "eDragTaskMotion",
+                                    "eDragTaskLeave", "eDragTaskDrop",
+                                    "eDragTaskSourceEnd"};
+  MOZ_ASSERT(size_t(aTask) < ArrayLength(taskNames));
+  return taskNames[aTask];
+}
+#endif
+
+gboolean nsDragService::Schedule(DragTask aTask, nsWindow* aWindow,
+                                 GdkDragContext* aDragContext,
+                                 LayoutDeviceIntPoint aWindowPoint,
+                                 guint aTime) {
+  // If there is an existing leave or motion task scheduled, then that
+  // will be replaced.  When the new task is run, it will dispatch
+  // any necessary leave or motion events.
+
+  // If aTask is eDragTaskSourceEnd, then it will replace even a scheduled
+  // drop event (which could happen if the drop event has not been processed
+  // within the allowed time).  Otherwise, if we haven't yet run a scheduled
+  // drop or end task, just say that we are not ready to receive another
+  // drop.
+  LOGDRAGSERVICE("nsDragService::Schedule(%p) task %s window %p\n",
+                 aDragContext, GetDragServiceTaskName(aTask), aWindow);
+
+  if (mScheduledTask == eDragTaskSourceEnd ||
+      (mScheduledTask == eDragTaskDrop && aTask != eDragTaskSourceEnd)) {
+    LOGDRAGSERVICE("   task does not fit recent task %s, quit!\n",
+                   GetDragServiceTaskName(mScheduledTask));
+    return FALSE;
+  }
+
+  mScheduledTask = aTask;
+  mPendingWindow = aWindow;
+  mPendingDragContext = aDragContext;
+  mPendingWindowPoint = aWindowPoint;
+  mPendingTime = aTime;
+
+  if (!mTaskSource) {
+    // High priority is used here because we want to process motion events
+    // right after drag_motion event handler which is called by Gtk.
+    // An ideal scenario is to call TaskDispatchCallback() directly here
+    // but we can't do that. TaskDispatchCallback() spins gtk event loop
+    // while nsDragService::Schedule() is already called from event loop
+    // (by drag_motion* gtk_widget events) so that direct call will cause
+    // nested recursion.
+    mTaskSource = g_timeout_add_full(G_PRIORITY_HIGH, 0, TaskDispatchCallback,
+                                     this, nullptr);
+  }
+
+  // We need to reply to drag_motion event on Wayland immediately,
+  // see Bug 1730203.
+  if (widget::GdkIsWaylandDisplay() && mScheduledTask == eDragTaskMotion) {
+    UpdateDragAction(aDragContext);
+    ReplyToDragMotion(aDragContext, aTime);
+  }
+
+  return TRUE;
+}
+
+gboolean nsDragService::TaskDispatchCallback(gpointer data) {
+  RefPtr<nsDragService> dragService = static_cast<nsDragService*>(data);
+  AutoEventLoop loop(dragService);
+  return dragService->RunScheduledTask();
+}
+
+gboolean nsDragService::RunScheduledTask() {
+  LOGDRAGSERVICE(
+      "nsDragService::RunScheduledTask() task %s mTargetWindow %p "
+      "mPendingWindow %p\n",
+      GetDragServiceTaskName(mScheduledTask), mTargetWindow.get(),
+      mPendingWindow.get());
+
+  // Don't run RunScheduledTask() twice. As we use it in main thread only
+  // we don't need to be thread safe here.
+  if (mScheduledTaskIsRunning) {
+    LOGDRAGSERVICE("  sheduled task is already running, quit.");
+    return FALSE;
+  }
+  AutoRestore<bool> guard(mScheduledTaskIsRunning);
+  mScheduledTaskIsRunning = true;
+
+  if (mTargetWindow && mTargetWindow != mPendingWindow) {
+    LOGDRAGSERVICE("  dispatch eDragExit (%p)\n", mTargetWindow.get());
+    mTargetWindow->DispatchDragEvent(eDragExit, mTargetWindowPoint, 0);
+
+    if (!mSourceNode) {
+      // The drag that was initiated in a different app. End the drag
+      // session, since we're done with it for now (until the user drags
+      // back into this app).
+      EndDragSession(false, GetCurrentModifiers());
+    }
+  }
+
+  // It is possible that the pending state has been updated during dispatch
+  // of the leave event.  That's fine.
+
+  // Now we collect the pending state because, from this point on, we want
+  // to use the same state for all events dispatched.  All state is updated
+  // so that when other tasks are scheduled during dispatch here, this
+  // task is considered to have already been run.
+  bool positionHasChanged = mPendingWindow != mTargetWindow ||
+                            mPendingWindowPoint != mTargetWindowPoint;
+  DragTask task = mScheduledTask;
+  mScheduledTask = eDragTaskNone;
+  mTargetWindow = std::move(mPendingWindow);
+  mTargetWindowPoint = mPendingWindowPoint;
+
+  if (task == eDragTaskLeave || task == eDragTaskSourceEnd) {
+    LOGDRAGSERVICE("  quit, selected task %s\n", GetDragServiceTaskName(task));
+    if (task == eDragTaskSourceEnd) {
+      // Dispatch drag end events.
+      EndDragSession(true, GetCurrentModifiers());
+    }
+
+    // Nothing more to do
+    // Returning false removes the task source from the event loop.
+    mTaskSource = 0;
+    return FALSE;
+  }
+
+  // This may be the start of a destination drag session.
+  StartDragSession();
+
+  // mTargetWidget may be nullptr if the window has been destroyed.
+  // (The leave event is not scheduled if a drop task is still scheduled.)
+  // We still reply appropriately to indicate that the drop will or didn't
+  // succeeed.
+  mTargetWidget = mTargetWindow ? mTargetWindow->GetGtkWidget() : nullptr;
+  LOGDRAGSERVICE("  start drag session mTargetWindow %p mTargetWidget %p\n",
+                 mTargetWindow.get(), mTargetWidget.get());
+  LOGDRAGSERVICE("  mPendingDragContext %p => mTargetDragContext %p\n",
+                 mPendingDragContext.get(), mTargetDragContext.get());
+  mTargetDragContext = std::move(mPendingDragContext);
+  mTargetTime = mPendingTime;
+
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#drag-and-drop-processing-model
+  // (as at 27 December 2010) indicates that a "drop" event should only be
+  // fired (at the current target element) if the current drag operation is
+  // not none.  The current drag operation will only be set to a non-none
+  // value during a "dragover" event.
+  //
+  // If the user has ended the drag before any dragover events have been
+  // sent, then the spec recommends skipping the drop (because the current
+  // drag operation is none).  However, here we assume that, by releasing
+  // the mouse button, the user has indicated that they want to drop, so we
+  // proceed with the drop where possible.
+  //
+  // In order to make the events appear to content in the same way as if the
+  // spec is being followed we make sure to dispatch a "dragover" event with
+  // appropriate coordinates and check canDrop before the "drop" event.
+  //
+  // When the Xdnd protocol is used for source/destination communication (as
+  // should be the case with GTK source applications) a dragover event
+  // should have already been sent during the drag-motion signal, which
+  // would have already been received because XdndDrop messages do not
+  // contain a position.  However, we can't assume the same when the Motif
+  // protocol is used.
+  if (task == eDragTaskMotion || positionHasChanged) {
+    LOGDRAGSERVICE("  process motion event\n");
+    UpdateDragAction();
+    TakeDragEventDispatchedToChildProcess();  // Clear the old value.
+    DispatchMotionEvents();
+    if (task == eDragTaskMotion) {
+      if (TakeDragEventDispatchedToChildProcess()) {
+        mTargetDragContextForRemote = mTargetDragContext;
+      } else {
+        // Reply to tell the source whether we can drop and what
+        // action would be taken.
+        ReplyToDragMotion();
+      }
+    }
+  }
+
+  if (task == eDragTaskDrop) {
+    LOGDRAGSERVICE("  process drop task\n");
+    gboolean success = DispatchDropEvent();
+
+    // Perhaps we should set the del parameter to TRUE when the drag
+    // action is move, but we don't know whether the data was successfully
+    // transferred.
+    if (mTargetDragContext) {
+      LOGDRAGSERVICE("  drag finished\n");
+      gtk_drag_finish(mTargetDragContext, success,
+                      /* del = */ FALSE, mTargetTime);
+    }
+    // Make sure to end the drag session. If this drag started in a
+    // different app, we won't get a drag_end signal to end it from.
+    EndDragSession(true, GetCurrentModifiers());
+  }
+
+  // We're done with the drag context.
+  LOGDRAGSERVICE("  clear mTargetWindow mTargetWidget and other data\n");
+  mTargetWidget = nullptr;
+  mTargetDragContext = nullptr;
+
+  // If we got another drag signal while running the sheduled task, that
+  // must have happened while running a nested event loop.  Leave the task
+  // source on the event loop.
+  if (mScheduledTask != eDragTaskNone) return TRUE;
+
+  // We have no task scheduled.
+  // Returning false removes the task source from the event loop.
+  LOGDRAGSERVICE("  remove task source\n");
+  mTaskSource = 0;
+  return FALSE;
+}
+
+// This will update the drag action based on the information in the
+// drag context.  Gtk gets this from a combination of the key settings
+// and what the source is offering.
+
+void nsDragService::UpdateDragAction(GdkDragContext* aDragContext) {
+  // This doesn't look right.  dragSession.dragAction is used by
+  // nsContentUtils::SetDataTransferInEvent() to set the initial
+  // dataTransfer.dropEffect, so GdkDragContext::suggested_action would be
+  // more appropriate.  GdkDragContext::actions should be used to set
+  // dataTransfer.effectAllowed, which doesn't currently happen with
+  // external sources.
+  LOGDRAGSERVICE("nsDragService::UpdateDragAction(%p)", aDragContext);
+
+  // default is to do nothing
+  int action = nsIDragService::DRAGDROP_ACTION_NONE;
+  GdkDragAction gdkAction = GDK_ACTION_DEFAULT;
+  if (aDragContext) {
+    gdkAction = gdk_drag_context_get_actions(aDragContext);
+    LOGDRAGSERVICE("  gdk_drag_context_get_actions() returns 0x%X", gdkAction);
+
+    // When D&D modifiers (CTRL/SHIFT) are involved,
+    // gdk_drag_context_get_actions() on X11 returns selected action but
+    // Wayland returns all allowed actions.
+
+    // So we need to call gdk_drag_context_get_selected_action() on Wayland
+    // to get potential D&D modifier.
+    // gdk_drag_context_get_selected_action() is also affected by
+    // gdk_drag_status(), see nsDragService::ReplyToDragMotion().
+    if (widget::GdkIsWaylandDisplay()) {
+      GdkDragAction gdkActionSelected =
+          gdk_drag_context_get_selected_action(aDragContext);
+      LOGDRAGSERVICE("  gdk_drag_context_get_selected_action() returns 0x%X",
+                     gdkActionSelected);
+      if (gdkActionSelected) {
+        gdkAction = gdkActionSelected;
+      }
+    }
+  }
+
+  // set the default just in case nothing matches below
+  if (gdkAction & GDK_ACTION_DEFAULT) {
+    LOGDRAGSERVICE("  set default move");
+    action = nsIDragService::DRAGDROP_ACTION_MOVE;
+  }
+  // first check to see if move is set
+  if (gdkAction & GDK_ACTION_MOVE) {
+    LOGDRAGSERVICE("  set explicit move");
+    action = nsIDragService::DRAGDROP_ACTION_MOVE;
+  } else if (gdkAction & GDK_ACTION_LINK) {
+    // then fall to the others
+    LOGDRAGSERVICE("  set explicit link");
+    action = nsIDragService::DRAGDROP_ACTION_LINK;
+  } else if (gdkAction & GDK_ACTION_COPY) {
+    // copy is ctrl
+    LOGDRAGSERVICE("  set explicit copy");
+    action = nsIDragService::DRAGDROP_ACTION_COPY;
+  }
+
+  // update the drag information
+  SetDragAction(action);
+}
+
+void nsDragService::UpdateDragAction() { UpdateDragAction(mTargetDragContext); }
+
+NS_IMETHODIMP
+nsDragService::UpdateDragEffect() {
+  LOGDRAGSERVICE("nsDragService::UpdateDragEffect() from e10s child process");
+  if (mTargetDragContextForRemote) {
+    ReplyToDragMotion(mTargetDragContextForRemote, mTargetTime);
+    mTargetDragContextForRemote = nullptr;
+  }
+  return NS_OK;
+}
+
+void nsDragService::ReplyToDragMotion() {
+  if (mTargetDragContext) {
+    ReplyToDragMotion(mTargetDragContext, mTargetTime);
+  }
+}
+
+void nsDragService::DispatchMotionEvents() {
+  FireDragEventAtSource(eDrag, GetCurrentModifiers());
+  if (mTargetWindow) {
+    mTargetWindow->DispatchDragEvent(eDragOver, mTargetWindowPoint,
+                                     mTargetTime);
+  }
+}
+
+// Returns true if the drop was successful
+gboolean nsDragService::DispatchDropEvent() {
+  // We need to check IsDestroyed here because the nsRefPtr
+  // only protects this from being deleted, it does NOT protect
+  // against nsView::~nsView() calling Destroy() on it, bug 378273.
+  if (!mTargetWindow || mTargetWindow->IsDestroyed()) {
+    return FALSE;
+  }
+
+  EventMessage msg = mCanDrop ? eDrop : eDragExit;
+
+  mTargetWindow->DispatchDragEvent(msg, mTargetWindowPoint, mTargetTime);
+
+  return mCanDrop;
+}
+
+/* static */
+uint32_t nsDragService::GetCurrentModifiers() {
+  return mozilla::widget::KeymapWrapper::ComputeCurrentKeyModifiers();
+}
+
+#undef LOGDRAGSERVICE
diff --git a/widget/gtk/nsDragService.h b/widget/gtk/nsDragService.h
new file mode 100644
index 0000000000..36696a75e2
--- /dev/null
+++ b/widget/gtk/nsDragService.h
@@ -0,0 +1,264 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsDragService_h__
+#define nsDragService_h__
+
+#include "mozilla/RefPtr.h"
+#include "nsBaseDragService.h"
+#include "nsCOMArray.h"
+#include "nsIObserver.h"
+#include <gtk/gtk.h>
+#include "nsITimer.h"
+
+class nsICookieJarSettings;
+class nsWindow;
+
+namespace mozilla {
+namespace gfx {
+class SourceSurface;
+}
+}  // namespace mozilla
+
+/**
+ * Native GTK DragService wrapper
+ */
+
+class nsDragService final : public nsBaseDragService, public nsIObserver {
+ public:
+  nsDragService();
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIOBSERVER
+
+  // nsBaseDragService
+  MOZ_CAN_RUN_SCRIPT virtual nsresult InvokeDragSessionImpl(
+      nsIArray* anArrayTransferables,
+      const mozilla::Maybe<mozilla::CSSIntRegion>& aRegion,
+      uint32_t aActionType) override;
+  // nsIDragService
+  MOZ_CAN_RUN_SCRIPT NS_IMETHOD InvokeDragSession(
+      nsINode* aDOMNode, nsIPrincipal* aPrincipal,
+      nsIContentSecurityPolicy* aCsp, nsICookieJarSettings* aCookieJarSettings,
+      nsIArray* anArrayTransferables, uint32_t aActionType,
+      nsContentPolicyType aContentPolicyType) override;
+  NS_IMETHOD StartDragSession() override;
+  MOZ_CAN_RUN_SCRIPT NS_IMETHOD EndDragSession(bool aDoneDrag,
+                                               uint32_t aKeyModifiers) override;
+
+  // nsIDragSession
+  NS_IMETHOD SetCanDrop(bool aCanDrop) override;
+  NS_IMETHOD GetCanDrop(bool* aCanDrop) override;
+  NS_IMETHOD GetNumDropItems(uint32_t* aNumItems) override;
+  NS_IMETHOD GetData(nsITransferable* aTransferable,
+                     uint32_t aItemIndex) override;
+  NS_IMETHOD IsDataFlavorSupported(const char* aDataFlavor,
+                                   bool* _retval) override;
+
+  // Update Drag&Drop state according child process state.
+  // UpdateDragEffect() is called by IPC bridge when child process
+  // accepts/denies D&D operation and uses stored
+  // mTargetDragContextForRemote context.
+  NS_IMETHOD UpdateDragEffect() override;
+
+  // Methods called from nsWindow to handle responding to GTK drag
+  // destination signals
+
+  static already_AddRefed<nsDragService> GetInstance();
+
+  void TargetDataReceived(GtkWidget* aWidget, GdkDragContext* aContext, gint aX,
+                          gint aY, GtkSelectionData* aSelection_data,
+                          guint aInfo, guint32 aTime);
+
+  gboolean ScheduleMotionEvent(nsWindow* aWindow, GdkDragContext* aDragContext,
+                               mozilla::LayoutDeviceIntPoint aWindowPoint,
+                               guint aTime);
+  void ScheduleLeaveEvent();
+  gboolean ScheduleDropEvent(nsWindow* aWindow, GdkDragContext* aDragContext,
+                             mozilla::LayoutDeviceIntPoint aWindowPoint,
+                             guint aTime);
+
+  nsWindow* GetMostRecentDestWindow() {
+    return mScheduledTask == eDragTaskNone ? mTargetWindow : mPendingWindow;
+  }
+
+  //  END PUBLIC API
+
+  // These methods are public only so that they can be called from functions
+  // with C calling conventions.  They are called for drags started with the
+  // invisible widget.
+  void SourceEndDragSession(GdkDragContext* aContext, gint aResult);
+  void SourceDataGet(GtkWidget* widget, GdkDragContext* context,
+                     GtkSelectionData* selection_data, guint32 aTime);
+  bool SourceDataGetText(nsITransferable* aItem, const nsACString& aMIMEType,
+                         bool aNeedToDoConversionToPlainText,
+                         GtkSelectionData* aSelectionData);
+  void SourceDataGetImage(nsITransferable* aItem,
+                          GtkSelectionData* aSelectionData);
+  void SourceDataGetXDND(nsITransferable* aItem, GdkDragContext* aContext,
+                         GtkSelectionData* aSelectionData);
+  void SourceDataGetUriList(GdkDragContext* aContext,
+                            GtkSelectionData* aSelectionData,
+                            uint32_t aDragItems);
+  bool SourceDataAppendURLFileItem(nsACString& aURI, nsITransferable* aItem);
+  bool SourceDataAppendURLItem(nsITransferable* aItem, bool aExternalDrop,
+                               nsACString& aURI);
+
+  void SourceBeginDrag(GdkDragContext* aContext);
+
+  // set the drag icon during drag-begin
+  void SetDragIcon(GdkDragContext* aContext);
+
+  class AutoEventLoop {
+    RefPtr<nsDragService> mService;
+
+   public:
+    explicit AutoEventLoop(RefPtr<nsDragService> aService)
+        : mService(std::move(aService)) {
+      mService->mEventLoopDepth++;
+    }
+    ~AutoEventLoop() { mService->mEventLoopDepth--; }
+  };
+  int GetLoopDepth() const { return mEventLoopDepth; };
+
+ protected:
+  virtual ~nsDragService();
+
+ private:
+  // mScheduledTask indicates what signal has been received from GTK and
+  // so what needs to be dispatched when the scheduled task is run.  It is
+  // eDragTaskNone when there is no task scheduled (but the
+  // previous task may still not have finished running).
+  enum DragTask {
+    eDragTaskNone,
+    eDragTaskMotion,
+    eDragTaskLeave,
+    eDragTaskDrop,
+    eDragTaskSourceEnd
+  };
+  DragTask mScheduledTask;
+  // mTaskSource is the GSource id for the task that is either scheduled
+  // or currently running.  It is 0 if no task is scheduled or running.
+  guint mTaskSource;
+  bool mScheduledTaskIsRunning;
+
+  // Where the drag begins. We need to keep it open on Wayland.
+  RefPtr<nsWindow> mSourceWindow;
+
+  // target/destination side vars
+  // These variables keep track of the state of the current drag.
+
+  // mPendingWindow, mPendingWindowPoint, mPendingDragContext, and
+  // mPendingTime, carry information from the GTK signal that will be used
+  // when the scheduled task is run.  mPendingWindow and mPendingDragContext
+  // will be nullptr if the scheduled task is eDragTaskLeave.
+  RefPtr<nsWindow> mPendingWindow;
+  mozilla::LayoutDeviceIntPoint mPendingWindowPoint;
+  RefPtr<GdkDragContext> mPendingDragContext;
+
+  // We cache all data for the current drag context,
+  // because waiting for the data in GetTargetDragData can be very slow.
+  nsTHashMap<nsCStringHashKey, nsTArray<uint8_t>> mCachedData;
+  // mCachedData are tied to mCachedDragContext. mCachedDragContext is not
+  // ref counted and may be already deleted on Gtk side.
+  // We used it for mCachedData invalidation only and can't be used for
+  // any D&D operation.
+  uintptr_t mCachedDragContext;
+
+  guint mPendingTime;
+
+  // mTargetWindow and mTargetWindowPoint record the position of the last
+  // eDragTaskMotion or eDragTaskDrop task that was run or is still running.
+  // mTargetWindow is cleared once the drag has completed or left.
+  RefPtr<nsWindow> mTargetWindow;
+  mozilla::LayoutDeviceIntPoint mTargetWindowPoint;
+  // mTargetWidget and mTargetDragContext are set only while dispatching
+  // motion or drop events.  mTime records the corresponding timestamp.
+  RefPtr<GtkWidget> mTargetWidget;
+  RefPtr<GdkDragContext> mTargetDragContext;
+
+  // When we route D'n'D request to child process
+  // (by EventStateManager::DispatchCrossProcessEvent)
+  // we save GdkDragContext to mTargetDragContextForRemote.
+  // When we get a reply from child process we use
+  // the stored GdkDragContext to send reply to OS.
+  //
+  // We need to store GdkDragContext because mTargetDragContext is cleared
+  // after every D'n'D event.
+  RefPtr<GdkDragContext> mTargetDragContextForRemote;
+  guint mTargetTime;
+
+  // is it OK to drop on us?
+  bool mCanDrop;
+
+  // have we received our drag data?
+  bool mTargetDragDataReceived;
+  // last data received and its length
+  void* mTargetDragData;
+  uint32_t mTargetDragDataLen;
+  // is the current target drag context contain a list?
+  bool IsTargetContextList(void);
+  // this will get the native data from the last target given a
+  // specific flavor
+  void GetTargetDragData(GdkAtom aFlavor, nsTArray<nsCString>& aDropFlavors);
+  // this will reset all of the target vars
+  void TargetResetData(void);
+  // Ensure our data cache belongs to aDragContext and clear the cache if
+  // aDragContext is different than mCachedDragContext.
+  void EnsureCachedDataValidForContext(GdkDragContext* aDragContext);
+
+  // source side vars
+
+  // the source of our drags
+  GtkWidget* mHiddenWidget;
+  // our source data items
+  nsCOMPtr<nsIArray> mSourceDataItems;
+
+  // get a list of the sources in gtk's format
+  GtkTargetList* GetSourceList(void);
+
+  // attempts to create a semi-transparent drag image. Returns TRUE if
+  // successful, FALSE if not
+  bool SetAlphaPixmap(SourceSurface* aPixbuf, GdkDragContext* aContext,
+                      int32_t aXOffset, int32_t aYOffset,
+                      const mozilla::LayoutDeviceIntRect& dragRect);
+
+  gboolean Schedule(DragTask aTask, nsWindow* aWindow,
+                    GdkDragContext* aDragContext,
+                    mozilla::LayoutDeviceIntPoint aWindowPoint, guint aTime);
+
+  // Callback for g_idle_add_full() to run mScheduledTask.
+  MOZ_CAN_RUN_SCRIPT static gboolean TaskDispatchCallback(gpointer data);
+  MOZ_CAN_RUN_SCRIPT gboolean RunScheduledTask();
+  MOZ_CAN_RUN_SCRIPT void DispatchMotionEvents();
+  void ReplyToDragMotion(GdkDragContext* aDragContext, guint aTime);
+  void ReplyToDragMotion();
+  void UpdateDragAction(GdkDragContext* aDragContext);
+  void UpdateDragAction();
+
+#ifdef MOZ_LOGGING
+  const char* GetDragServiceTaskName(nsDragService::DragTask aTask);
+#endif
+  void GetDragFlavors(nsTArray<nsCString>& aFlavors);
+  gboolean DispatchDropEvent();
+  static uint32_t GetCurrentModifiers();
+
+  nsresult CreateTempFile(nsITransferable* aItem, nsACString& aURI);
+  bool RemoveTempFiles();
+  static gboolean TaskRemoveTempFiles(gpointer data);
+
+  // the url of the temporary file that has been created in the current drag
+  // session
+  nsTArray<nsCString> mTempFileUrls;
+  // stores all temporary files
+  nsCOMArray<nsIFile> mTemporaryFiles;
+  // timer to trigger deletion of temporary files
+  guint mTempFileTimerID;
+  // How deep we're nested in event loops
+  int mEventLoopDepth;
+};
+
+#endif  // nsDragService_h__
diff --git a/widget/gtk/nsFilePicker.cpp b/widget/gtk/nsFilePicker.cpp
new file mode 100644
index 0000000000..5c8a9451fc
--- /dev/null
+++ b/widget/gtk/nsFilePicker.cpp
@@ -0,0 +1,652 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <dlfcn.h>
+#include <gtk/gtk.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "mozilla/Types.h"
+#include "nsGtkUtils.h"
+#include "nsIFileURL.h"
+#include "nsIGIOService.h"
+#include "nsIURI.h"
+#include "nsIWidget.h"
+#include "nsIFile.h"
+#include "mozilla/Preferences.h"
+
+#include "nsArrayEnumerator.h"
+#include "nsEnumeratorUtils.h"
+#include "nsNetUtil.h"
+#include "nsReadableUtils.h"
+#include "MozContainer.h"
+#include "WidgetUtilsGtk.h"
+
+#include "nsFilePicker.h"
+
+#undef LOG
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+extern mozilla::LazyLogModule gWidgetLog;
+#  define LOG(args) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, args)
+#else
+#  define LOG(args)
+#endif /* MOZ_LOGGING */
+
+using namespace mozilla;
+
+#define MAX_PREVIEW_SIZE 180
+// bug 1184009
+#define MAX_PREVIEW_SOURCE_SIZE 4096
+
+nsIFile* nsFilePicker::mPrevDisplayDirectory = nullptr;
+
+void nsFilePicker::Shutdown() { NS_IF_RELEASE(mPrevDisplayDirectory); }
+
+static GtkFileChooserAction GetGtkFileChooserAction(int16_t aMode) {
+  GtkFileChooserAction action;
+
+  switch (aMode) {
+    case nsIFilePicker::modeSave:
+      action = GTK_FILE_CHOOSER_ACTION_SAVE;
+      break;
+
+    case nsIFilePicker::modeGetFolder:
+      action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
+      break;
+
+    case nsIFilePicker::modeOpen:
+    case nsIFilePicker::modeOpenMultiple:
+      action = GTK_FILE_CHOOSER_ACTION_OPEN;
+      break;
+
+    default:
+      NS_WARNING("Unknown nsIFilePicker mode");
+      action = GTK_FILE_CHOOSER_ACTION_OPEN;
+      break;
+  }
+
+  return action;
+}
+
+static void UpdateFilePreviewWidget(GtkFileChooser* file_chooser,
+                                    gpointer preview_widget_voidptr) {
+  GtkImage* preview_widget = GTK_IMAGE(preview_widget_voidptr);
+  char* image_filename = gtk_file_chooser_get_preview_filename(file_chooser);
+  struct stat st_buf;
+
+  if (!image_filename) {
+    gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
+    return;
+  }
+
+  gint preview_width = 0;
+  gint preview_height = 0;
+  /* check type of file
+   * if file is named pipe, Open is blocking which may lead to UI
+   *  nonresponsiveness; if file is directory/socket, it also isn't
+   *  likely to get preview */
+  if (stat(image_filename, &st_buf) || (!S_ISREG(st_buf.st_mode))) {
+    g_free(image_filename);
+    gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
+    return; /* stat failed or file is not regular */
+  }
+
+  GdkPixbufFormat* preview_format =
+      gdk_pixbuf_get_file_info(image_filename, &preview_width, &preview_height);
+  if (!preview_format || preview_width <= 0 || preview_height <= 0 ||
+      preview_width > MAX_PREVIEW_SOURCE_SIZE ||
+      preview_height > MAX_PREVIEW_SOURCE_SIZE) {
+    g_free(image_filename);
+    gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
+    return;
+  }
+
+  GdkPixbuf* preview_pixbuf = nullptr;
+  // Only scale down images that are too big
+  if (preview_width > MAX_PREVIEW_SIZE || preview_height > MAX_PREVIEW_SIZE) {
+    preview_pixbuf = gdk_pixbuf_new_from_file_at_size(
+        image_filename, MAX_PREVIEW_SIZE, MAX_PREVIEW_SIZE, nullptr);
+  } else {
+    preview_pixbuf = gdk_pixbuf_new_from_file(image_filename, nullptr);
+  }
+
+  g_free(image_filename);
+
+  if (!preview_pixbuf) {
+    gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
+    return;
+  }
+
+  GdkPixbuf* preview_pixbuf_temp = preview_pixbuf;
+  preview_pixbuf = gdk_pixbuf_apply_embedded_orientation(preview_pixbuf_temp);
+  g_object_unref(preview_pixbuf_temp);
+
+  // This is the easiest way to do center alignment without worrying about
+  // containers Minimum 3px padding each side (hence the 6) just to make things
+  // nice
+  gint x_padding =
+      (MAX_PREVIEW_SIZE + 6 - gdk_pixbuf_get_width(preview_pixbuf)) / 2;
+  gtk_misc_set_padding(GTK_MISC(preview_widget), x_padding, 0);
+
+  gtk_image_set_from_pixbuf(preview_widget, preview_pixbuf);
+  g_object_unref(preview_pixbuf);
+  gtk_file_chooser_set_preview_widget_active(file_chooser, TRUE);
+}
+
+static nsAutoCString MakeCaseInsensitiveShellGlob(const char* aPattern) {
+  // aPattern is UTF8
+  nsAutoCString result;
+  unsigned int len = strlen(aPattern);
+
+  for (unsigned int i = 0; i < len; i++) {
+    if (!g_ascii_isalpha(aPattern[i])) {
+      // non-ASCII characters will also trigger this path, so unicode
+      // is safely handled albeit case-sensitively
+      result.Append(aPattern[i]);
+      continue;
+    }
+
+    // add the lowercase and uppercase version of a character to a bracket
+    // match, so it matches either the lowercase or uppercase char.
+    result.Append('[');
+    result.Append(g_ascii_tolower(aPattern[i]));
+    result.Append(g_ascii_toupper(aPattern[i]));
+    result.Append(']');
+  }
+
+  return result;
+}
+
+NS_IMPL_ISUPPORTS(nsFilePicker, nsIFilePicker)
+
+nsFilePicker::nsFilePicker()
+    : mSelectedType(0),
+      mRunning(false),
+      mAllowURLs(false),
+      mFileChooserDelegate(nullptr) {
+  mUseNativeFileChooser =
+      widget::ShouldUsePortal(widget::PortalKind::FilePicker);
+}
+
+nsFilePicker::~nsFilePicker() = default;
+
+void ReadMultipleFiles(gpointer filename, gpointer array) {
+  nsCOMPtr<nsIFile> localfile;
+  nsresult rv =
+      NS_NewNativeLocalFile(nsDependentCString(static_cast<char*>(filename)),
+                            false, getter_AddRefs(localfile));
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMArray<nsIFile>& files = *static_cast<nsCOMArray<nsIFile>*>(array);
+    files.AppendObject(localfile);
+  }
+
+  g_free(filename);
+}
+
+void nsFilePicker::ReadValuesFromFileChooser(void* file_chooser) {
+  mFiles.Clear();
+
+  if (mMode == nsIFilePicker::modeOpenMultiple) {
+    mFileURL.Truncate();
+
+    GSList* list =
+        gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
+    g_slist_foreach(list, ReadMultipleFiles, static_cast<gpointer>(&mFiles));
+    g_slist_free(list);
+  } else {
+    gchar* filename = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(file_chooser));
+    mFileURL.Assign(filename);
+    g_free(filename);
+  }
+
+  GtkFileFilter* filter =
+      gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(file_chooser));
+  GSList* filter_list =
+      gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(file_chooser));
+
+  mSelectedType = static_cast<int16_t>(g_slist_index(filter_list, filter));
+  g_slist_free(filter_list);
+
+  // Remember last used directory.
+  nsCOMPtr<nsIFile> file;
+  GetFile(getter_AddRefs(file));
+  if (file) {
+    nsCOMPtr<nsIFile> dir;
+    file->GetParent(getter_AddRefs(dir));
+    if (dir) {
+      dir.swap(mPrevDisplayDirectory);
+    }
+  }
+}
+
+void nsFilePicker::InitNative(nsIWidget* aParent, const nsAString& aTitle) {
+  mParentWidget = aParent;
+  mTitle.Assign(aTitle);
+}
+
+NS_IMETHODIMP
+nsFilePicker::AppendFilters(int32_t aFilterMask) {
+  mAllowURLs = !!(aFilterMask & filterAllowURLs);
+  return nsBaseFilePicker::AppendFilters(aFilterMask);
+}
+
+NS_IMETHODIMP
+nsFilePicker::AppendFilter(const nsAString& aTitle, const nsAString& aFilter) {
+  if (aFilter.EqualsLiteral("..apps")) {
+    // No platform specific thing we can do here, really....
+    return NS_OK;
+  }
+
+  nsAutoCString filter, name;
+  CopyUTF16toUTF8(aFilter, filter);
+  CopyUTF16toUTF8(aTitle, name);
+
+  mFilters.AppendElement(filter);
+  mFilterNames.AppendElement(name);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::SetDefaultString(const nsAString& aString) {
+  mDefault = aString;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetDefaultString(nsAString& aString) {
+  // Per API...
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsFilePicker::SetDefaultExtension(const nsAString& aExtension) {
+  mDefaultExtension = aExtension;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetDefaultExtension(nsAString& aExtension) {
+  aExtension = mDefaultExtension;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFilterIndex(int32_t* aFilterIndex) {
+  *aFilterIndex = mSelectedType;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::SetFilterIndex(int32_t aFilterIndex) {
+  mSelectedType = aFilterIndex;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFile(nsIFile** aFile) {
+  NS_ENSURE_ARG_POINTER(aFile);
+
+  *aFile = nullptr;
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = GetFileURL(getter_AddRefs(uri));
+  if (!uri) return rv;
+
+  nsCOMPtr<nsIFileURL> fileURL(do_QueryInterface(uri, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> file;
+  rv = fileURL->GetFile(getter_AddRefs(file));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  file.forget(aFile);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFileURL(nsIURI** aFileURL) {
+  *aFileURL = nullptr;
+  return NS_NewURI(aFileURL, mFileURL);
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFiles(nsISimpleEnumerator** aFiles) {
+  NS_ENSURE_ARG_POINTER(aFiles);
+
+  if (mMode == nsIFilePicker::modeOpenMultiple) {
+    return NS_NewArrayEnumerator(aFiles, mFiles, NS_GET_IID(nsIFile));
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+nsresult nsFilePicker::Show(int16_t* aReturn) {
+  NS_ENSURE_ARG_POINTER(aReturn);
+
+  nsresult rv = Open(nullptr);
+  if (NS_FAILED(rv)) return rv;
+
+  while (mRunning) {
+    g_main_context_iteration(nullptr, TRUE);
+  }
+
+  *aReturn = mResult;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::Open(nsIFilePickerShownCallback* aCallback) {
+  // Can't show two dialogs concurrently with the same filepicker
+  if (mRunning) return NS_ERROR_NOT_AVAILABLE;
+
+  NS_ConvertUTF16toUTF8 title(mTitle);
+
+  GtkWindow* parent_widget =
+      GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET));
+
+  GtkFileChooserAction action = GetGtkFileChooserAction(mMode);
+
+  const gchar* accept_button;
+  NS_ConvertUTF16toUTF8 buttonLabel(mOkButtonLabel);
+  if (!mOkButtonLabel.IsEmpty()) {
+    accept_button = buttonLabel.get();
+  } else {
+    accept_button = nullptr;
+  }
+
+  void* file_chooser =
+      GtkFileChooserNew(title.get(), parent_widget, action, accept_button);
+
+  // If we have --enable-proxy-bypass-protection, then don't allow
+  // remote URLs to be used.
+#ifndef MOZ_PROXY_BYPASS_PROTECTION
+  if (mAllowURLs) {
+    gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser), FALSE);
+  }
+#endif
+
+  if (action == GTK_FILE_CHOOSER_ACTION_OPEN ||
+      action == GTK_FILE_CHOOSER_ACTION_SAVE) {
+    GtkWidget* img_preview = gtk_image_new();
+    gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(file_chooser),
+                                        img_preview);
+    g_signal_connect(file_chooser, "update-preview",
+                     G_CALLBACK(UpdateFilePreviewWidget), img_preview);
+  }
+
+  GtkFileChooserSetModal(file_chooser, parent_widget, TRUE);
+
+  NS_ConvertUTF16toUTF8 defaultName(mDefault);
+  switch (mMode) {
+    case nsIFilePicker::modeOpenMultiple:
+      gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser),
+                                           TRUE);
+      break;
+    case nsIFilePicker::modeSave:
+      gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser),
+                                        defaultName.get());
+      break;
+  }
+
+  nsCOMPtr<nsIFile> defaultPath;
+  if (mDisplayDirectory) {
+    mDisplayDirectory->Clone(getter_AddRefs(defaultPath));
+  } else if (mPrevDisplayDirectory) {
+    mPrevDisplayDirectory->Clone(getter_AddRefs(defaultPath));
+  }
+
+  if (defaultPath) {
+    if (!defaultName.IsEmpty() && mMode != nsIFilePicker::modeSave) {
+      // Try to select the intended file. Even if it doesn't exist, GTK still
+      // switches directories.
+      defaultPath->AppendNative(defaultName);
+      nsAutoCString path;
+      defaultPath->GetNativePath(path);
+      gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser), path.get());
+    } else {
+      nsAutoCString directory;
+      defaultPath->GetNativePath(directory);
+
+      // Workaround for problematic refcounting in GTK3 before 3.16.
+      // We need to keep a reference to the dialog's internal delegate.
+      // Otherwise, if our dialog gets destroyed, we'll lose the dialog's
+      // delegate by the time this gets processed in the event loop.
+      // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1166741
+      if (GTK_IS_DIALOG(file_chooser)) {
+        GtkDialog* dialog = GTK_DIALOG(file_chooser);
+        GtkContainer* area = GTK_CONTAINER(gtk_dialog_get_content_area(dialog));
+        gtk_container_forall(
+            area,
+            [](GtkWidget* widget, gpointer data) {
+              if (GTK_IS_FILE_CHOOSER_WIDGET(widget)) {
+                auto result = static_cast<GtkFileChooserWidget**>(data);
+                *result = GTK_FILE_CHOOSER_WIDGET(widget);
+              }
+            },
+            &mFileChooserDelegate);
+
+        if (mFileChooserDelegate != nullptr) {
+          g_object_ref(mFileChooserDelegate);
+        }
+      }
+      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser),
+                                          directory.get());
+    }
+  }
+
+  if (GTK_IS_DIALOG(file_chooser)) {
+    gtk_dialog_set_default_response(GTK_DIALOG(file_chooser),
+                                    GTK_RESPONSE_ACCEPT);
+  }
+
+  int32_t count = mFilters.Length();
+  for (int32_t i = 0; i < count; ++i) {
+    // This is fun... the GTK file picker does not accept a list of filters
+    // so we need to split out each string, and add it manually.
+
+    char** patterns = g_strsplit(mFilters[i].get(), ";", -1);
+    if (!patterns) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    GtkFileFilter* filter = gtk_file_filter_new();
+    for (int j = 0; patterns[j] != nullptr; ++j) {
+      nsAutoCString caseInsensitiveFilter =
+          MakeCaseInsensitiveShellGlob(g_strstrip(patterns[j]));
+      gtk_file_filter_add_pattern(filter, caseInsensitiveFilter.get());
+    }
+
+    g_strfreev(patterns);
+
+    if (!mFilterNames[i].IsEmpty()) {
+      // If we have a name for our filter, let's use that.
+      const char* filter_name = mFilterNames[i].get();
+      gtk_file_filter_set_name(filter, filter_name);
+    } else {
+      // If we don't have a name, let's just use the filter pattern.
+      const char* filter_pattern = mFilters[i].get();
+      gtk_file_filter_set_name(filter, filter_pattern);
+    }
+
+    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
+
+    // Set the initially selected filter
+    if (mSelectedType == i) {
+      gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter);
+    }
+  }
+
+  gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser),
+                                                 TRUE);
+
+  mRunning = true;
+  mCallback = aCallback;
+  NS_ADDREF_THIS();
+  g_signal_connect(file_chooser, "response", G_CALLBACK(OnResponse), this);
+  GtkFileChooserShow(file_chooser);
+
+  return NS_OK;
+}
+
+/* static */
+void nsFilePicker::OnResponse(void* file_chooser, gint response_id,
+                              gpointer user_data) {
+  static_cast<nsFilePicker*>(user_data)->Done(file_chooser, response_id);
+}
+
+/* static */
+void nsFilePicker::OnDestroy(GtkWidget* file_chooser, gpointer user_data) {
+  static_cast<nsFilePicker*>(user_data)->Done(file_chooser,
+                                              GTK_RESPONSE_CANCEL);
+}
+
+void nsFilePicker::Done(void* file_chooser, gint response) {
+  mRunning = false;
+
+  int16_t result;
+  switch (response) {
+    case GTK_RESPONSE_OK:
+    case GTK_RESPONSE_ACCEPT:
+      ReadValuesFromFileChooser(file_chooser);
+      result = nsIFilePicker::returnOK;
+      if (mMode == nsIFilePicker::modeSave) {
+        nsCOMPtr<nsIFile> file;
+        GetFile(getter_AddRefs(file));
+        if (file) {
+          bool exists = false;
+          file->Exists(&exists);
+          if (exists) result = nsIFilePicker::returnReplace;
+        }
+      }
+      break;
+
+    case GTK_RESPONSE_CANCEL:
+    case GTK_RESPONSE_CLOSE:
+    case GTK_RESPONSE_DELETE_EVENT:
+      result = nsIFilePicker::returnCancel;
+      break;
+
+    default:
+      NS_WARNING("Unexpected response");
+      result = nsIFilePicker::returnCancel;
+      break;
+  }
+
+  // A "response" signal won't be sent again but "destroy" will be.
+  g_signal_handlers_disconnect_by_func(file_chooser, FuncToGpointer(OnDestroy),
+                                       this);
+
+  // When response_id is GTK_RESPONSE_DELETE_EVENT or when called from
+  // OnDestroy, the widget would be destroyed anyway but it is fine if
+  // gtk_widget_destroy is called more than once.  gtk_widget_destroy has
+  // requests that any remaining references be released, but the reference
+  // count will not be decremented again if GtkWindow's reference has already
+  // been released.
+  GtkFileChooserDestroy(file_chooser);
+
+  if (mFileChooserDelegate) {
+    // Properly deref our acquired reference. We call this after
+    // gtk_widget_destroy() to try and ensure that pending file info
+    // queries caused by updating the current folder have been cancelled.
+    // However, we do not know for certain when the callback will run after
+    // cancelled.
+    g_idle_add(
+        [](gpointer data) -> gboolean {
+          g_object_unref(data);
+          return G_SOURCE_REMOVE;
+        },
+        mFileChooserDelegate);
+    mFileChooserDelegate = nullptr;
+  }
+
+  if (mCallback) {
+    mCallback->Done(result);
+    mCallback = nullptr;
+  } else {
+    mResult = result;
+  }
+  NS_RELEASE_THIS();
+}
+
+// All below functions available as of GTK 3.20+
+void* nsFilePicker::GtkFileChooserNew(const gchar* title, GtkWindow* parent,
+                                      GtkFileChooserAction action,
+                                      const gchar* accept_label) {
+  static auto sGtkFileChooserNativeNewPtr =
+      (void* (*)(const gchar*, GtkWindow*, GtkFileChooserAction, const gchar*,
+                 const gchar*))dlsym(RTLD_DEFAULT,
+                                     "gtk_file_chooser_native_new");
+  if (mUseNativeFileChooser && sGtkFileChooserNativeNewPtr != nullptr) {
+    return (*sGtkFileChooserNativeNewPtr)(title, parent, action, accept_label,
+                                          nullptr);
+  }
+  if (accept_label == nullptr) {
+    accept_label = (action == GTK_FILE_CHOOSER_ACTION_SAVE) ? GTK_STOCK_SAVE
+                                                            : GTK_STOCK_OPEN;
+  }
+  GtkWidget* file_chooser = gtk_file_chooser_dialog_new(
+      title, parent, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+      accept_label, GTK_RESPONSE_ACCEPT, nullptr);
+  gtk_dialog_set_alternative_button_order(
+      GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1);
+  return file_chooser;
+}
+
+void nsFilePicker::GtkFileChooserShow(void* file_chooser) {
+  static auto sGtkNativeDialogShowPtr =
+      (void (*)(void*))dlsym(RTLD_DEFAULT, "gtk_native_dialog_show");
+  if (mUseNativeFileChooser && sGtkNativeDialogShowPtr != nullptr) {
+    const char* portalEnvString = g_getenv("GTK_USE_PORTAL");
+    bool setPortalEnv =
+        (portalEnvString && *portalEnvString == '0') || !portalEnvString;
+    if (setPortalEnv) {
+      setenv("GTK_USE_PORTAL", "1", true);
+    }
+    (*sGtkNativeDialogShowPtr)(file_chooser);
+    if (setPortalEnv) {
+      unsetenv("GTK_USE_PORTAL");
+    }
+  } else {
+    g_signal_connect(file_chooser, "destroy", G_CALLBACK(OnDestroy), this);
+    gtk_widget_show(GTK_WIDGET(file_chooser));
+  }
+}
+
+void nsFilePicker::GtkFileChooserDestroy(void* file_chooser) {
+  static auto sGtkNativeDialogDestroyPtr =
+      (void (*)(void*))dlsym(RTLD_DEFAULT, "gtk_native_dialog_destroy");
+  if (mUseNativeFileChooser && sGtkNativeDialogDestroyPtr != nullptr) {
+    (*sGtkNativeDialogDestroyPtr)(file_chooser);
+  } else {
+    gtk_widget_destroy(GTK_WIDGET(file_chooser));
+  }
+}
+
+void nsFilePicker::GtkFileChooserSetModal(void* file_chooser,
+                                          GtkWindow* parent_widget,
+                                          gboolean modal) {
+  static auto sGtkNativeDialogSetModalPtr = (void (*)(void*, gboolean))dlsym(
+      RTLD_DEFAULT, "gtk_native_dialog_set_modal");
+  if (mUseNativeFileChooser && sGtkNativeDialogSetModalPtr != nullptr) {
+    (*sGtkNativeDialogSetModalPtr)(file_chooser, modal);
+  } else {
+    GtkWindow* window = GTK_WINDOW(file_chooser);
+    gtk_window_set_modal(window, modal);
+    if (parent_widget != nullptr) {
+      gtk_window_set_destroy_with_parent(window, modal);
+    }
+  }
+}
+
+#undef LOG
diff --git a/widget/gtk/nsFilePicker.h b/widget/gtk/nsFilePicker.h
new file mode 100644
index 0000000000..9b3110aa00
--- /dev/null
+++ b/widget/gtk/nsFilePicker.h
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsFilePicker_h__
+#define nsFilePicker_h__
+
+#include <gtk/gtk.h>
+
+#include "nsBaseFilePicker.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsCOMArray.h"
+
+class nsIWidget;
+class nsIFile;
+
+class nsFilePicker : public nsBaseFilePicker {
+ public:
+  nsFilePicker();
+
+  NS_DECL_ISUPPORTS
+
+  // nsIFilePicker (less what's in nsBaseFilePicker)
+  NS_IMETHOD Open(nsIFilePickerShownCallback* aCallback) override;
+  NS_IMETHOD AppendFilters(int32_t aFilterMask) override;
+  NS_IMETHOD AppendFilter(const nsAString& aTitle,
+                          const nsAString& aFilter) override;
+  NS_IMETHOD SetDefaultString(const nsAString& aString) override;
+  NS_IMETHOD GetDefaultString(nsAString& aString) override;
+  NS_IMETHOD SetDefaultExtension(const nsAString& aExtension) override;
+  NS_IMETHOD GetDefaultExtension(nsAString& aExtension) override;
+  NS_IMETHOD GetFilterIndex(int32_t* aFilterIndex) override;
+  NS_IMETHOD SetFilterIndex(int32_t aFilterIndex) override;
+  NS_IMETHOD GetFile(nsIFile** aFile) override;
+  NS_IMETHOD GetFileURL(nsIURI** aFileURL) override;
+  NS_IMETHOD GetFiles(nsISimpleEnumerator** aFiles) override;
+
+  // nsBaseFilePicker
+  virtual void InitNative(nsIWidget* aParent, const nsAString& aTitle) override;
+
+  static void Shutdown();
+
+ protected:
+  virtual ~nsFilePicker();
+
+  nsresult Show(int16_t* aReturn) override;
+  void ReadValuesFromFileChooser(void* file_chooser);
+
+  static void OnResponse(void* file_chooser, gint response_id,
+                         gpointer user_data);
+  static void OnDestroy(GtkWidget* file_chooser, gpointer user_data);
+  void Done(void* file_chooser, gint response_id);
+
+  nsCOMPtr<nsIWidget> mParentWidget;
+  nsCOMPtr<nsIFilePickerShownCallback> mCallback;
+  nsCOMArray<nsIFile> mFiles;
+
+  int16_t mSelectedType;
+  int16_t mResult;
+  bool mRunning;
+  bool mAllowURLs;
+  nsCString mFileURL;
+  nsString mTitle;
+  nsString mDefault;
+  nsString mDefaultExtension;
+
+  nsTArray<nsCString> mFilters;
+  nsTArray<nsCString> mFilterNames;
+
+ private:
+  static nsIFile* mPrevDisplayDirectory;
+
+  void* GtkFileChooserNew(const gchar* title, GtkWindow* parent,
+                          GtkFileChooserAction action,
+                          const gchar* accept_label);
+  void GtkFileChooserShow(void* file_chooser);
+  void GtkFileChooserDestroy(void* file_chooser);
+  void GtkFileChooserSetModal(void* file_chooser, GtkWindow* parent_widget,
+                              gboolean modal);
+
+  GtkFileChooserWidget* mFileChooserDelegate;
+  bool mUseNativeFileChooser;
+};
+
+#endif
diff --git a/widget/gtk/nsGTKToolkit.h b/widget/gtk/nsGTKToolkit.h
new file mode 100644
index 0000000000..5129ba419d
--- /dev/null
+++ b/widget/gtk/nsGTKToolkit.h
@@ -0,0 +1,52 @@
+/* -*- 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 GTKTOOLKIT_H
+#define GTKTOOLKIT_H
+
+#include "nsString.h"
+#include <gtk/gtk.h>
+
+/**
+ * Wrapper around the thread running the message pump.
+ * The toolkit abstraction is necessary because the message pump must
+ * execute within the same thread that created the widget under Win32.
+ */
+
+class nsGTKToolkit final {
+ public:
+  nsGTKToolkit() = default;
+
+  static nsGTKToolkit* GetToolkit();
+  static void Shutdown() {
+    delete gToolkit;
+    gToolkit = nullptr;
+  }
+
+  /**
+   * Get/set our startup token value. (XDG_ACTIVATION_TOKEN/DESKTOP_STARTUP_ID)
+   * When non-empty, this is applied to the next toplevel window to be shown or
+   * focused (and then immediately cleared).
+   */
+  void SetStartupToken(const nsACString& aToken) { mStartupToken = aToken; }
+  const nsCString& GetStartupToken() const { return mStartupToken; }
+
+  /**
+   * Get/set the timestamp value to be used, if non-zero, to focus the
+   * next top-level window to be shown or focused (upon which it is cleared).
+   */
+  void SetFocusTimestamp(uint32_t aTimestamp) { mFocusTimestamp = aTimestamp; }
+  uint32_t GetFocusTimestamp() const { return mFocusTimestamp; }
+
+ private:
+  static nsGTKToolkit* gToolkit;
+
+  nsCString mStartupToken;
+  uint32_t mFocusTimestamp = 0;
+};
+
+#endif  // GTKTOOLKIT_H
diff --git a/widget/gtk/nsGtkCursors.h b/widget/gtk/nsGtkCursors.h
new file mode 100644
index 0000000000..f30ed593a9
--- /dev/null
+++ b/widget/gtk/nsGtkCursors.h
@@ -0,0 +1,416 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsGtkCursors_h__
+#define nsGtkCursors_h__
+
+typedef struct {
+  const unsigned char* bits;
+  const unsigned char* mask_bits;
+  int hot_x;
+  int hot_y;
+  const char* hash;
+} nsGtkCursor;
+
+/* MOZ_CURSOR_HAND_GRAB */
+static const unsigned char moz_hand_grab_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x60, 0x39, 0x00, 0x00, 0x90, 0x49, 0x00, 0x00, 0x90, 0x49, 0x01, 0x00,
+    0x20, 0xc9, 0x02, 0x00, 0x20, 0x49, 0x02, 0x00, 0x58, 0x40, 0x02, 0x00,
+    0x64, 0x00, 0x02, 0x00, 0x44, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00,
+    0x10, 0x00, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x20, 0x80, 0x00, 0x00,
+    0x40, 0x40, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_hand_grab_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x60, 0x3f, 0x00, 0x00,
+    0xf0, 0x7f, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0xf8, 0xff, 0x03, 0x00,
+    0xf0, 0xff, 0x07, 0x00, 0xf8, 0xff, 0x07, 0x00, 0xfc, 0xff, 0x07, 0x00,
+    0xfe, 0xff, 0x07, 0x00, 0xfe, 0xff, 0x03, 0x00, 0xfc, 0xff, 0x03, 0x00,
+    0xf8, 0xff, 0x03, 0x00, 0xf8, 0xff, 0x01, 0x00, 0xf0, 0xff, 0x01, 0x00,
+    0xe0, 0xff, 0x00, 0x00, 0xc0, 0xff, 0x00, 0x00, 0xc0, 0xff, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_HAND_GRABBING */
+static const unsigned char moz_hand_grabbing_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc0, 0x36, 0x00, 0x00, 0x20, 0xc9, 0x00, 0x00, 0x20, 0x40, 0x01, 0x00,
+    0x40, 0x00, 0x01, 0x00, 0x60, 0x00, 0x01, 0x00, 0x10, 0x00, 0x01, 0x00,
+    0x10, 0x00, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x20, 0x80, 0x00, 0x00,
+    0x40, 0x40, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_hand_grabbing_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x36, 0x00, 0x00,
+    0xe0, 0xff, 0x00, 0x00, 0xf0, 0xff, 0x01, 0x00, 0xf0, 0xff, 0x03, 0x00,
+    0xe0, 0xff, 0x03, 0x00, 0xf0, 0xff, 0x03, 0x00, 0xf8, 0xff, 0x03, 0x00,
+    0xf8, 0xff, 0x03, 0x00, 0xf8, 0xff, 0x01, 0x00, 0xf0, 0xff, 0x01, 0x00,
+    0xe0, 0xff, 0x00, 0x00, 0xc0, 0xff, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_COPY */
+static const unsigned char moz_copy_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+    0x7c, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x01, 0x00, 0x00,
+    0xfc, 0x03, 0x00, 0x00, 0x7c, 0x30, 0x00, 0x00, 0x6c, 0x30, 0x00, 0x00,
+    0xc4, 0xfc, 0x00, 0x00, 0xc0, 0xfc, 0x00, 0x00, 0x80, 0x31, 0x00, 0x00,
+    0x80, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_copy_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0xfe, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00,
+    0xfe, 0x37, 0x00, 0x00, 0xfe, 0x7b, 0x00, 0x00, 0xfe, 0xfc, 0x00, 0x00,
+    0xee, 0xff, 0x01, 0x00, 0xe4, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x00, 0x00,
+    0xc0, 0x7b, 0x00, 0x00, 0x80, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_ALIAS */
+static const unsigned char moz_alias_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+    0x7c, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x01, 0x00, 0x00,
+    0xfc, 0x03, 0x00, 0x00, 0x7c, 0xf0, 0x00, 0x00, 0x6c, 0xe0, 0x00, 0x00,
+    0xc4, 0xf0, 0x00, 0x00, 0xc0, 0xb0, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00,
+    0x80, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_alias_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0xfe, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00,
+    0xfe, 0xf7, 0x00, 0x00, 0xfe, 0xfb, 0x01, 0x00, 0xfe, 0xf0, 0x01, 0x00,
+    0xee, 0xf9, 0x01, 0x00, 0xe4, 0xf9, 0x01, 0x00, 0xc0, 0xbf, 0x00, 0x00,
+    0xc0, 0x3f, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_CONTEXT_MENU */
+static const unsigned char moz_menu_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+    0x7c, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0xfd, 0x00, 0x00,
+    0xfc, 0xff, 0x00, 0x00, 0x7c, 0x84, 0x00, 0x00, 0x6c, 0xfc, 0x00, 0x00,
+    0xc4, 0x84, 0x00, 0x00, 0xc0, 0xfc, 0x00, 0x00, 0x80, 0x85, 0x00, 0x00,
+    0x80, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_menu_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0xfe, 0x00, 0x00, 0x00, 0xfe, 0xfd, 0x00, 0x00, 0xfe, 0xff, 0x01, 0x00,
+    0xfe, 0xff, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xfe, 0x01, 0x00,
+    0xee, 0xff, 0x01, 0x00, 0xe4, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x01, 0x00,
+    0xc0, 0xff, 0x01, 0x00, 0x80, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_SPINNING */
+static const unsigned char moz_spinning_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+    0x7c, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x01, 0x00, 0x00,
+    0xfc, 0x3b, 0x00, 0x00, 0x7c, 0x38, 0x00, 0x00, 0x6c, 0x54, 0x00, 0x00,
+    0xc4, 0xdc, 0x00, 0x00, 0xc0, 0x44, 0x00, 0x00, 0x80, 0x39, 0x00, 0x00,
+    0x80, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_spinning_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0xfe, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xfe, 0x3b, 0x00, 0x00,
+    0xfe, 0x7f, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00,
+    0xee, 0xff, 0x01, 0x00, 0xe4, 0xff, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00,
+    0xc0, 0x7f, 0x00, 0x00, 0x80, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_ZOOM_IN */
+static const unsigned char moz_zoom_in_bits[] = {
+    0xf0, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00,
+    0x62, 0x04, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0xf9, 0x09, 0x00, 0x00,
+    0xf9, 0x09, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0x62, 0x04, 0x00, 0x00,
+    0x02, 0x04, 0x00, 0x00, 0x0c, 0x0f, 0x00, 0x00, 0xf0, 0x1c, 0x00, 0x00,
+    0x00, 0x38, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
+    0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_zoom_in_mask_bits[] = {
+    0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00,
+    0xfe, 0x07, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00,
+    0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00,
+    0xfe, 0x07, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0xf0, 0x1c, 0x00, 0x00,
+    0x00, 0x38, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
+    0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_ZOOM_OUT */
+static const unsigned char moz_zoom_out_bits[] = {
+    0xf0, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00,
+    0x02, 0x04, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0xf9, 0x09, 0x00, 0x00,
+    0xf9, 0x09, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00,
+    0x02, 0x04, 0x00, 0x00, 0x0c, 0x0f, 0x00, 0x00, 0xf0, 0x1c, 0x00, 0x00,
+    0x00, 0x38, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
+    0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_zoom_out_mask_bits[] = {
+    0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00,
+    0xfe, 0x07, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00,
+    0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00,
+    0xfe, 0x07, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0xf0, 0x1c, 0x00, 0x00,
+    0x00, 0x38, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
+    0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_NOT_ALLOWED */
+static const unsigned char moz_not_allowed_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00,
+    0xf0, 0xf0, 0x00, 0x00, 0x38, 0xc0, 0x01, 0x00, 0x7c, 0x80, 0x03, 0x00,
+    0xec, 0x00, 0x03, 0x00, 0xce, 0x01, 0x07, 0x00, 0x86, 0x03, 0x06, 0x00,
+    0x06, 0x07, 0x06, 0x00, 0x06, 0x0e, 0x06, 0x00, 0x06, 0x1c, 0x06, 0x00,
+    0x0e, 0x38, 0x07, 0x00, 0x0c, 0x70, 0x03, 0x00, 0x1c, 0xe0, 0x03, 0x00,
+    0x38, 0xc0, 0x01, 0x00, 0xf0, 0xf0, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00,
+    0x80, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_not_allowed_mask_bits[] = {
+    0x80, 0x1f, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0xf0, 0xff, 0x00, 0x00,
+    0xf8, 0xff, 0x01, 0x00, 0xfc, 0xf0, 0x03, 0x00, 0xfe, 0xc0, 0x07, 0x00,
+    0xfe, 0x81, 0x07, 0x00, 0xff, 0x83, 0x0f, 0x00, 0xcf, 0x07, 0x0f, 0x00,
+    0x8f, 0x0f, 0x0f, 0x00, 0x0f, 0x1f, 0x0f, 0x00, 0x0f, 0x3e, 0x0f, 0x00,
+    0x1f, 0xfc, 0x0f, 0x00, 0x1e, 0xf8, 0x07, 0x00, 0x3e, 0xf0, 0x07, 0x00,
+    0xfc, 0xf0, 0x03, 0x00, 0xf8, 0xff, 0x01, 0x00, 0xf0, 0xff, 0x00, 0x00,
+    0xe0, 0x7f, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_VERTICAL_TEXT */
+static const unsigned char moz_vertical_text_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00,
+    0x06, 0x60, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00,
+    0x02, 0x40, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_vertical_text_mask_bits[] = {
+    0x07, 0xe0, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00,
+    0xff, 0xff, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+    0x0f, 0xf0, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_NESW_RESIZE */
+static const unsigned char moz_nesw_resize_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
+    0x00, 0xbe, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00,
+    0x02, 0xb4, 0x00, 0x00, 0x02, 0xa2, 0x00, 0x00, 0x02, 0x81, 0x00, 0x00,
+    0x8a, 0x80, 0x00, 0x00, 0x5a, 0x80, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
+    0x7a, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0xfe, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_nesw_resize_mask_bits[] = {
+    0xc0, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x01, 0x00,
+    0x00, 0xff, 0x01, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xfc, 0x01, 0x00,
+    0x07, 0xfe, 0x01, 0x00, 0x07, 0xf7, 0x01, 0x00, 0x8f, 0xe3, 0x01, 0x00,
+    0xdf, 0xc1, 0x01, 0x00, 0xff, 0xc0, 0x01, 0x00, 0x7f, 0x00, 0x00, 0x00,
+    0xff, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00,
+    0xff, 0x07, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_NWSE_RESIZE */
+static const unsigned char moz_nwse_resize_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0xfa, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
+    0x5a, 0x80, 0x00, 0x00, 0x8a, 0x80, 0x00, 0x00, 0x02, 0x81, 0x00, 0x00,
+    0x02, 0xa2, 0x00, 0x00, 0x02, 0xb4, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00,
+    0x00, 0xbc, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
+    0xc0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_nwse_resize_mask_bits[] = {
+    0xff, 0x07, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00,
+    0xff, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00,
+    0xff, 0xc0, 0x01, 0x00, 0xdf, 0xc1, 0x01, 0x00, 0x8f, 0xe3, 0x01, 0x00,
+    0x07, 0xf7, 0x01, 0x00, 0x07, 0xfe, 0x01, 0x00, 0x00, 0xfc, 0x01, 0x00,
+    0x00, 0xfe, 0x01, 0x00, 0x00, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x01, 0x00,
+    0xc0, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+/* MOZ_CURSOR_NONE */
+static const unsigned char moz_none_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char moz_none_mask_bits[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+enum {
+  MOZ_CURSOR_HAND_GRAB,
+  MOZ_CURSOR_HAND_GRABBING,
+  MOZ_CURSOR_COPY,
+  MOZ_CURSOR_ALIAS,
+  MOZ_CURSOR_CONTEXT_MENU,
+  MOZ_CURSOR_SPINNING,
+  MOZ_CURSOR_ZOOM_IN,
+  MOZ_CURSOR_ZOOM_OUT,
+  MOZ_CURSOR_NOT_ALLOWED,
+  MOZ_CURSOR_VERTICAL_TEXT,
+  MOZ_CURSOR_NESW_RESIZE,
+  MOZ_CURSOR_NWSE_RESIZE,
+  MOZ_CURSOR_NONE
+};
+
+// create custom pixmap cursor. The hash values must stay in sync with the
+// bitmap data above. To see the hash function, have a look at XcursorImageHash
+// in libXcursor
+static const nsGtkCursor GtkCursors[] = {
+    {moz_hand_grab_bits, moz_hand_grab_mask_bits, 10, 10,
+     "5aca4d189052212118709018842178c0"},
+    {moz_hand_grabbing_bits, moz_hand_grabbing_mask_bits, 10, 10,
+     "208530c400c041818281048008011002"},
+    {moz_copy_bits, moz_copy_mask_bits, 2, 2,
+     "08ffe1cb5fe6fc01f906f1c063814ccf"},
+    {moz_alias_bits, moz_alias_mask_bits, 2, 2,
+     "0876e1c15ff2fc01f906f1c363074c0f"},
+    {moz_menu_bits, moz_menu_mask_bits, 2, 2,
+     "08ffe1e65f80fcfdf9fff11263e74c48"},
+    {moz_spinning_bits, moz_spinning_mask_bits, 2, 2,
+     "08e8e1c95fe2fc01f976f1e063a24ccd"},
+    {moz_zoom_in_bits, moz_zoom_in_mask_bits, 6, 6,
+     "f41c0e382c94c0958e07017e42b00462"},
+    {moz_zoom_out_bits, moz_zoom_out_mask_bits, 6, 6,
+     "f41c0e382c97c0938e07017e42800402"},
+    {moz_not_allowed_bits, moz_not_allowed_mask_bits, 9, 9,
+     "03b6e0fcb3499374a867d041f52298f0"},
+    {moz_vertical_text_bits, moz_vertical_text_mask_bits, 8, 4,
+     "048008013003cff3c00c801001200000"},
+    {moz_nesw_resize_bits, moz_nesw_resize_mask_bits, 8, 8,
+     "50585d75b494802d0151028115016902"},
+    {moz_nwse_resize_bits, moz_nwse_resize_mask_bits, 8, 8,
+     "38c5dff7c7b8962045400281044508d2"},
+    {moz_none_bits, moz_none_mask_bits, 0, 0, nullptr}};
+
+#endif /* nsGtkCursors_h__ */
diff --git a/widget/gtk/nsGtkKeyUtils.cpp b/widget/gtk/nsGtkKeyUtils.cpp
new file mode 100644
index 0000000000..1ef4d62bf6
--- /dev/null
+++ b/widget/gtk/nsGtkKeyUtils.cpp
@@ -0,0 +1,2488 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Logging.h"
+
+#include "nsGtkKeyUtils.h"
+
+#include <gdk/gdkkeysyms.h>
+#include <algorithm>
+#include <gdk/gdk.h>
+#include <dlfcn.h>
+#include <gdk/gdkkeysyms-compat.h>
+#ifdef MOZ_X11
+#  include <gdk/gdkx.h>
+#  include <X11/XKBlib.h>
+#  include "X11UndefineNone.h"
+#endif
+#include "IMContextWrapper.h"
+#include "WidgetUtils.h"
+#include "WidgetUtilsGtk.h"
+#include "x11/keysym2ucs.h"
+#include "nsContentUtils.h"
+#include "nsGtkUtils.h"
+#include "nsIBidiKeyboard.h"
+#include "nsPrintfCString.h"
+#include "nsReadableUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsWindow.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TextEventDispatcher.h"
+#include "mozilla/TextEvents.h"
+
+#ifdef MOZ_WAYLAND
+#  include <sys/mman.h>
+#  include "nsWaylandDisplay.h"
+#endif
+
+// For collecting other people's log, tell them `MOZ_LOG=KeyboardHandler:4,sync`
+// rather than `MOZ_LOG=KeyboardHandler:5,sync` since using `5` may create too
+// big file.
+// Therefore you shouldn't use `LogLevel::Verbose` for logging usual behavior.
+mozilla::LazyLogModule gKeyLog("KeyboardHandler");
+
+namespace mozilla {
+namespace widget {
+
+#define IS_ASCII_ALPHABETICAL(key) \
+  ((('a' <= key) && (key <= 'z')) || (('A' <= key) && (key <= 'Z')))
+
+#define MOZ_MODIFIER_KEYS "MozKeymapWrapper"
+
+KeymapWrapper* KeymapWrapper::sInstance = nullptr;
+guint KeymapWrapper::sLastRepeatableHardwareKeyCode = 0;
+#ifdef MOZ_X11
+Time KeymapWrapper::sLastRepeatableKeyTime = 0;
+#endif
+KeymapWrapper::RepeatState KeymapWrapper::sRepeatState =
+    KeymapWrapper::NOT_PRESSED;
+
+static const char* GetBoolName(bool aBool) { return aBool ? "TRUE" : "FALSE"; }
+
+static const char* GetStatusName(nsEventStatus aStatus) {
+  switch (aStatus) {
+    case nsEventStatus_eConsumeDoDefault:
+      return "nsEventStatus_eConsumeDoDefault";
+    case nsEventStatus_eConsumeNoDefault:
+      return "nsEventStatus_eConsumeNoDefault";
+    case nsEventStatus_eIgnore:
+      return "nsEventStatus_eIgnore";
+    case nsEventStatus_eSentinel:
+      return "nsEventStatus_eSentinel";
+    default:
+      return "Illegal value";
+  }
+}
+
+static const nsCString GetKeyLocationName(uint32_t aLocation) {
+  switch (aLocation) {
+    case eKeyLocationLeft:
+      return "KEY_LOCATION_LEFT"_ns;
+    case eKeyLocationRight:
+      return "KEY_LOCATION_RIGHT"_ns;
+    case eKeyLocationStandard:
+      return "KEY_LOCATION_STANDARD"_ns;
+    case eKeyLocationNumpad:
+      return "KEY_LOCATION_NUMPAD"_ns;
+    default:
+      return nsPrintfCString("Unknown (0x%04X)", aLocation);
+  }
+}
+
+static const nsCString GetCharacterCodeName(char16_t aChar) {
+  switch (aChar) {
+    case 0x0000:
+      return "NULL (0x0000)"_ns;
+    case 0x0008:
+      return "BACKSPACE (0x0008)"_ns;
+    case 0x0009:
+      return "CHARACTER TABULATION (0x0009)"_ns;
+    case 0x000A:
+      return "LINE FEED (0x000A)"_ns;
+    case 0x000B:
+      return "LINE TABULATION (0x000B)"_ns;
+    case 0x000C:
+      return "FORM FEED (0x000C)"_ns;
+    case 0x000D:
+      return "CARRIAGE RETURN (0x000D)"_ns;
+    case 0x0018:
+      return "CANCEL (0x0018)"_ns;
+    case 0x001B:
+      return "ESCAPE (0x001B)"_ns;
+    case 0x0020:
+      return "SPACE (0x0020)"_ns;
+    case 0x007F:
+      return "DELETE (0x007F)"_ns;
+    case 0x00A0:
+      return "NO-BREAK SPACE (0x00A0)"_ns;
+    case 0x00AD:
+      return "SOFT HYPHEN (0x00AD)"_ns;
+    case 0x2000:
+      return "EN QUAD (0x2000)"_ns;
+    case 0x2001:
+      return "EM QUAD (0x2001)"_ns;
+    case 0x2002:
+      return "EN SPACE (0x2002)"_ns;
+    case 0x2003:
+      return "EM SPACE (0x2003)"_ns;
+    case 0x2004:
+      return "THREE-PER-EM SPACE (0x2004)"_ns;
+    case 0x2005:
+      return "FOUR-PER-EM SPACE (0x2005)"_ns;
+    case 0x2006:
+      return "SIX-PER-EM SPACE (0x2006)"_ns;
+    case 0x2007:
+      return "FIGURE SPACE (0x2007)"_ns;
+    case 0x2008:
+      return "PUNCTUATION SPACE (0x2008)"_ns;
+    case 0x2009:
+      return "THIN SPACE (0x2009)"_ns;
+    case 0x200A:
+      return "HAIR SPACE (0x200A)"_ns;
+    case 0x200B:
+      return "ZERO WIDTH SPACE (0x200B)"_ns;
+    case 0x200C:
+      return "ZERO WIDTH NON-JOINER (0x200C)"_ns;
+    case 0x200D:
+      return "ZERO WIDTH JOINER (0x200D)"_ns;
+    case 0x200E:
+      return "LEFT-TO-RIGHT MARK (0x200E)"_ns;
+    case 0x200F:
+      return "RIGHT-TO-LEFT MARK (0x200F)"_ns;
+    case 0x2029:
+      return "PARAGRAPH SEPARATOR (0x2029)"_ns;
+    case 0x202A:
+      return "LEFT-TO-RIGHT EMBEDDING (0x202A)"_ns;
+    case 0x202B:
+      return "RIGHT-TO-LEFT EMBEDDING (0x202B)"_ns;
+    case 0x202D:
+      return "LEFT-TO-RIGHT OVERRIDE (0x202D)"_ns;
+    case 0x202E:
+      return "RIGHT-TO-LEFT OVERRIDE (0x202E)"_ns;
+    case 0x202F:
+      return "NARROW NO-BREAK SPACE (0x202F)"_ns;
+    case 0x205F:
+      return "MEDIUM MATHEMATICAL SPACE (0x205F)"_ns;
+    case 0x2060:
+      return "WORD JOINER (0x2060)"_ns;
+    case 0x2066:
+      return "LEFT-TO-RIGHT ISOLATE (0x2066)"_ns;
+    case 0x2067:
+      return "RIGHT-TO-LEFT ISOLATE (0x2067)"_ns;
+    case 0x3000:
+      return "IDEOGRAPHIC SPACE (0x3000)"_ns;
+    case 0xFEFF:
+      return "ZERO WIDTH NO-BREAK SPACE (0xFEFF)"_ns;
+    default: {
+      if (aChar < ' ' || (aChar >= 0x80 && aChar < 0xA0)) {
+        return nsPrintfCString("control (0x%04X)", aChar);
+      }
+      if (NS_IS_HIGH_SURROGATE(aChar)) {
+        return nsPrintfCString("high surrogate (0x%04X)", aChar);
+      }
+      if (NS_IS_LOW_SURROGATE(aChar)) {
+        return nsPrintfCString("low surrogate (0x%04X)", aChar);
+      }
+      return nsPrintfCString("'%s' (0x%04X)",
+                             NS_ConvertUTF16toUTF8(nsAutoString(aChar)).get(),
+                             aChar);
+    }
+  }
+}
+
+static const nsCString GetCharacterCodeNames(const char16_t* aChars,
+                                             uint32_t aLength) {
+  if (!aLength) {
+    return "\"\""_ns;
+  }
+  nsCString result;
+  result.AssignLiteral("\"");
+  StringJoinAppend(result, ", "_ns, Span{aChars, aLength},
+                   [](nsACString& dest, const char16_t charValue) {
+                     dest.Append(GetCharacterCodeName(charValue));
+                   });
+  result.AppendLiteral("\"");
+  return result;
+}
+
+static const nsCString GetCharacterCodeNames(const nsAString& aString) {
+  return GetCharacterCodeNames(aString.BeginReading(), aString.Length());
+}
+
+/* static */ const char* KeymapWrapper::GetModifierName(Modifier aModifier) {
+  switch (aModifier) {
+    case CAPS_LOCK:
+      return "CapsLock";
+    case NUM_LOCK:
+      return "NumLock";
+    case SCROLL_LOCK:
+      return "ScrollLock";
+    case SHIFT:
+      return "Shift";
+    case CTRL:
+      return "Ctrl";
+    case ALT:
+      return "Alt";
+    case SUPER:
+      return "Super";
+    case HYPER:
+      return "Hyper";
+    case META:
+      return "Meta";
+    case LEVEL3:
+      return "Level3";
+    case LEVEL5:
+      return "Level5";
+    case NOT_MODIFIER:
+      return "NotModifier";
+    default:
+      return "InvalidValue";
+  }
+}
+
+/* static */ KeymapWrapper::Modifier KeymapWrapper::GetModifierForGDKKeyval(
+    guint aGdkKeyval) {
+  switch (aGdkKeyval) {
+    case GDK_Caps_Lock:
+      return CAPS_LOCK;
+    case GDK_Num_Lock:
+      return NUM_LOCK;
+    case GDK_Scroll_Lock:
+      return SCROLL_LOCK;
+    case GDK_Shift_Lock:
+    case GDK_Shift_L:
+    case GDK_Shift_R:
+      return SHIFT;
+    case GDK_Control_L:
+    case GDK_Control_R:
+      return CTRL;
+    case GDK_Alt_L:
+    case GDK_Alt_R:
+      return ALT;
+    case GDK_Super_L:
+    case GDK_Super_R:
+      return SUPER;
+    case GDK_Hyper_L:
+    case GDK_Hyper_R:
+      return HYPER;
+    case GDK_Meta_L:
+    case GDK_Meta_R:
+      return META;
+    case GDK_ISO_Level3_Shift:
+    case GDK_Mode_switch:
+      return LEVEL3;
+    case GDK_ISO_Level5_Shift:
+      return LEVEL5;
+    default:
+      return NOT_MODIFIER;
+  }
+}
+
+guint KeymapWrapper::GetModifierMask(Modifier aModifier) const {
+  switch (aModifier) {
+    case CAPS_LOCK:
+      return GDK_LOCK_MASK;
+    case NUM_LOCK:
+      return mModifierMasks[INDEX_NUM_LOCK];
+    case SCROLL_LOCK:
+      return mModifierMasks[INDEX_SCROLL_LOCK];
+    case SHIFT:
+      return GDK_SHIFT_MASK;
+    case CTRL:
+      return GDK_CONTROL_MASK;
+    case ALT:
+      return mModifierMasks[INDEX_ALT];
+    case SUPER:
+      return mModifierMasks[INDEX_SUPER];
+    case HYPER:
+      return mModifierMasks[INDEX_HYPER];
+    case META:
+      return mModifierMasks[INDEX_META];
+    case LEVEL3:
+      return mModifierMasks[INDEX_LEVEL3];
+    case LEVEL5:
+      return mModifierMasks[INDEX_LEVEL5];
+    default:
+      return 0;
+  }
+}
+
+KeymapWrapper::ModifierKey* KeymapWrapper::GetModifierKey(
+    guint aHardwareKeycode) {
+  for (uint32_t i = 0; i < mModifierKeys.Length(); i++) {
+    ModifierKey& key = mModifierKeys[i];
+    if (key.mHardwareKeycode == aHardwareKeycode) {
+      return &key;
+    }
+  }
+  return nullptr;
+}
+
+/* static */
+KeymapWrapper* KeymapWrapper::GetInstance() {
+  if (sInstance) {
+    sInstance->Init();
+    return sInstance;
+  }
+
+  sInstance = new KeymapWrapper();
+  return sInstance;
+}
+
+#ifdef MOZ_WAYLAND
+void KeymapWrapper::EnsureInstance() { (void)GetInstance(); }
+#endif
+
+/* static */
+void KeymapWrapper::Shutdown() {
+  if (sInstance) {
+    delete sInstance;
+    sInstance = nullptr;
+  }
+}
+
+KeymapWrapper::KeymapWrapper()
+    : mInitialized(false),
+      mGdkKeymap(gdk_keymap_get_default()),
+      mXKBBaseEventCode(0),
+      mOnKeysChangedSignalHandle(0),
+      mOnDirectionChangedSignalHandle(0) {
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p Constructor, mGdkKeymap=%p", this, mGdkKeymap));
+
+  g_object_ref(mGdkKeymap);
+
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    InitXKBExtension();
+  }
+#endif
+
+  Init();
+}
+
+void KeymapWrapper::Init() {
+  if (mInitialized) {
+    return;
+  }
+  mInitialized = true;
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p Init, mGdkKeymap=%p", this, mGdkKeymap));
+
+  mModifierKeys.Clear();
+  memset(mModifierMasks, 0, sizeof(mModifierMasks));
+
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    InitBySystemSettingsX11();
+  }
+#endif
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay()) {
+    InitBySystemSettingsWayland();
+  }
+#endif
+
+#ifdef MOZ_X11
+  gdk_window_add_filter(nullptr, FilterEvents, this);
+#endif
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p Init, CapsLock=0x%X, NumLock=0x%X, "
+           "ScrollLock=0x%X, Level3=0x%X, Level5=0x%X, "
+           "Shift=0x%X, Ctrl=0x%X, Alt=0x%X, Meta=0x%X, Super=0x%X, Hyper=0x%X",
+           this, GetModifierMask(CAPS_LOCK), GetModifierMask(NUM_LOCK),
+           GetModifierMask(SCROLL_LOCK), GetModifierMask(LEVEL3),
+           GetModifierMask(LEVEL5), GetModifierMask(SHIFT),
+           GetModifierMask(CTRL), GetModifierMask(ALT), GetModifierMask(META),
+           GetModifierMask(SUPER), GetModifierMask(HYPER)));
+}
+
+#ifdef MOZ_X11
+void KeymapWrapper::InitXKBExtension() {
+  PodZero(&mKeyboardState);
+
+  int xkbMajorVer = XkbMajorVersion;
+  int xkbMinorVer = XkbMinorVersion;
+  if (!XkbLibraryVersion(&xkbMajorVer, &xkbMinorVer)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p InitXKBExtension failed due to failure of "
+             "XkbLibraryVersion()",
+             this));
+    return;
+  }
+
+  Display* display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
+
+  // XkbLibraryVersion() set xkbMajorVer and xkbMinorVer to that of the
+  // library, which may be newer than what is required of the server in
+  // XkbQueryExtension(), so these variables should be reset to
+  // XkbMajorVersion and XkbMinorVersion before the XkbQueryExtension call.
+  xkbMajorVer = XkbMajorVersion;
+  xkbMinorVer = XkbMinorVersion;
+  int opcode, baseErrorCode;
+  if (!XkbQueryExtension(display, &opcode, &mXKBBaseEventCode, &baseErrorCode,
+                         &xkbMajorVer, &xkbMinorVer)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitXKBExtension failed due to failure of "
+             "XkbQueryExtension(), display=0x%p",
+             this, display));
+    return;
+  }
+
+  if (!XkbSelectEventDetails(display, XkbUseCoreKbd, XkbStateNotify,
+                             XkbModifierStateMask, XkbModifierStateMask)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitXKBExtension failed due to failure of "
+             "XkbSelectEventDetails() for XModifierStateMask, display=0x%p",
+             this, display));
+    return;
+  }
+
+  if (!XkbSelectEventDetails(display, XkbUseCoreKbd, XkbControlsNotify,
+                             XkbPerKeyRepeatMask, XkbPerKeyRepeatMask)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitXKBExtension failed due to failure of "
+             "XkbSelectEventDetails() for XkbControlsNotify, display=0x%p",
+             this, display));
+    return;
+  }
+
+  if (!XGetKeyboardControl(display, &mKeyboardState)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitXKBExtension failed due to failure of "
+             "XGetKeyboardControl(), display=0x%p",
+             this, display));
+    return;
+  }
+
+  MOZ_LOG(gKeyLog, LogLevel::Info, ("%p   InitXKBExtension, Succeeded", this));
+}
+
+void KeymapWrapper::InitBySystemSettingsX11() {
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p InitBySystemSettingsX11, mGdkKeymap=%p", this, mGdkKeymap));
+
+  if (!mOnKeysChangedSignalHandle) {
+    mOnKeysChangedSignalHandle = g_signal_connect(
+        mGdkKeymap, "keys-changed", (GCallback)OnKeysChanged, this);
+  }
+  if (!mOnDirectionChangedSignalHandle) {
+    mOnDirectionChangedSignalHandle = g_signal_connect(
+        mGdkKeymap, "direction-changed", (GCallback)OnDirectionChanged, this);
+  }
+
+  Display* display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
+
+  int min_keycode = 0;
+  int max_keycode = 0;
+  XDisplayKeycodes(display, &min_keycode, &max_keycode);
+
+  int keysyms_per_keycode = 0;
+  KeySym* xkeymap =
+      XGetKeyboardMapping(display, min_keycode, max_keycode - min_keycode + 1,
+                          &keysyms_per_keycode);
+  if (!xkeymap) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitBySystemSettings, "
+             "Failed due to null xkeymap",
+             this));
+    return;
+  }
+
+  XModifierKeymap* xmodmap = XGetModifierMapping(display);
+  if (!xmodmap) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitBySystemSettings, "
+             "Failed due to null xmodmap",
+             this));
+    XFree(xkeymap);
+    return;
+  }
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p   InitBySystemSettings, min_keycode=%d, "
+           "max_keycode=%d, keysyms_per_keycode=%d, max_keypermod=%d",
+           this, min_keycode, max_keycode, keysyms_per_keycode,
+           xmodmap->max_keypermod));
+
+  // The modifiermap member of the XModifierKeymap structure contains 8 sets
+  // of max_keypermod KeyCodes, one for each modifier in the order Shift,
+  // Lock, Control, Mod1, Mod2, Mod3, Mod4, and Mod5.
+  // Only nonzero KeyCodes have meaning in each set, and zero KeyCodes are
+  // ignored.
+
+  // Note that two or more modifiers may use one modifier flag.  E.g.,
+  // on Ubuntu 10.10, Alt and Meta share the Mod1 in default settings.
+  // And also Super and Hyper share the Mod4. In such cases, we need to
+  // decide which modifier flag means one of DOM modifiers.
+
+  // mod[0] is Modifier introduced by Mod1.
+  Modifier mod[5];
+  int32_t foundLevel[5];
+  for (uint32_t i = 0; i < ArrayLength(mod); i++) {
+    mod[i] = NOT_MODIFIER;
+    foundLevel[i] = INT32_MAX;
+  }
+  const uint32_t map_size = 8 * xmodmap->max_keypermod;
+  for (uint32_t i = 0; i < map_size; i++) {
+    KeyCode keycode = xmodmap->modifiermap[i];
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p   InitBySystemSettings, "
+             "  i=%d, keycode=0x%08X",
+             this, i, keycode));
+    if (!keycode || keycode < min_keycode || keycode > max_keycode) {
+      continue;
+    }
+
+    ModifierKey* modifierKey = GetModifierKey(keycode);
+    if (!modifierKey) {
+      modifierKey = mModifierKeys.AppendElement(ModifierKey(keycode));
+    }
+
+    const KeySym* syms =
+        xkeymap + (keycode - min_keycode) * keysyms_per_keycode;
+    const uint32_t bit = i / xmodmap->max_keypermod;
+    modifierKey->mMask |= 1 << bit;
+
+    // We need to know the meaning of Mod1, Mod2, Mod3, Mod4 and Mod5.
+    // Let's skip if current map is for others.
+    if (bit < 3) {
+      continue;
+    }
+
+    const int32_t modIndex = bit - 3;
+    for (int32_t j = 0; j < keysyms_per_keycode; j++) {
+      Modifier modifier = GetModifierForGDKKeyval(syms[j]);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("%p   InitBySystemSettings, "
+               "    Mod%d, j=%d, syms[j]=%s(0x%lX), modifier=%s",
+               this, modIndex + 1, j, gdk_keyval_name(syms[j]), syms[j],
+               GetModifierName(modifier)));
+
+      switch (modifier) {
+        case NOT_MODIFIER:
+          // Don't overwrite the stored information with
+          // NOT_MODIFIER.
+          break;
+        case CAPS_LOCK:
+        case SHIFT:
+        case CTRL:
+          // Ignore the modifiers defined in GDK spec. They shouldn't
+          // be mapped to Mod1-5 because they must not work on native
+          // GTK applications.
+          break;
+        default:
+          // If new modifier is found in higher level than stored
+          // value, we don't need to overwrite it.
+          if (j > foundLevel[modIndex]) {
+            break;
+          }
+          // If new modifier is more important than stored value,
+          // we should overwrite it with new modifier.
+          if (j == foundLevel[modIndex]) {
+            mod[modIndex] = std::min(modifier, mod[modIndex]);
+            break;
+          }
+          foundLevel[modIndex] = j;
+          mod[modIndex] = modifier;
+          break;
+      }
+    }
+  }
+
+  for (uint32_t i = 0; i < COUNT_OF_MODIFIER_INDEX; i++) {
+    Modifier modifier;
+    switch (i) {
+      case INDEX_NUM_LOCK:
+        modifier = NUM_LOCK;
+        break;
+      case INDEX_SCROLL_LOCK:
+        modifier = SCROLL_LOCK;
+        break;
+      case INDEX_ALT:
+        modifier = ALT;
+        break;
+      case INDEX_META:
+        modifier = META;
+        break;
+      case INDEX_SUPER:
+        modifier = SUPER;
+        break;
+      case INDEX_HYPER:
+        modifier = HYPER;
+        break;
+      case INDEX_LEVEL3:
+        modifier = LEVEL3;
+        break;
+      case INDEX_LEVEL5:
+        modifier = LEVEL5;
+        break;
+      default:
+        MOZ_CRASH("All indexes must be handled here");
+    }
+    for (uint32_t j = 0; j < ArrayLength(mod); j++) {
+      if (modifier == mod[j]) {
+        mModifierMasks[i] |= 1 << (j + 3);
+      }
+    }
+  }
+
+  XFreeModifiermap(xmodmap);
+  XFree(xkeymap);
+}
+#endif
+
+#ifdef MOZ_WAYLAND
+void KeymapWrapper::SetModifierMask(xkb_keymap* aKeymap,
+                                    ModifierIndex aModifierIndex,
+                                    const char* aModifierName) {
+  static auto sXkbKeymapModGetIndex =
+      (xkb_mod_index_t(*)(struct xkb_keymap*, const char*))dlsym(
+          RTLD_DEFAULT, "xkb_keymap_mod_get_index");
+
+  xkb_mod_index_t index = sXkbKeymapModGetIndex(aKeymap, aModifierName);
+  if (index != XKB_MOD_INVALID) {
+    mModifierMasks[aModifierIndex] = (1 << index);
+  }
+}
+
+void KeymapWrapper::SetModifierMasks(xkb_keymap* aKeymap) {
+  KeymapWrapper* keymapWrapper = GetInstance();
+
+  // This mapping is derived from get_xkb_modifiers() at gdkkeys-wayland.c
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_NUM_LOCK, XKB_MOD_NAME_NUM);
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_ALT, XKB_MOD_NAME_ALT);
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_META, "Meta");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_SUPER, "Super");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_HYPER, "Hyper");
+
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_SCROLL_LOCK, "ScrollLock");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL3, "Level3");
+  keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL5, "Level5");
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p KeymapWrapper::SetModifierMasks, CapsLock=0x%X, NumLock=0x%X, "
+           "ScrollLock=0x%X, Level3=0x%X, Level5=0x%X, "
+           "Shift=0x%X, Ctrl=0x%X, Alt=0x%X, Meta=0x%X, Super=0x%X, Hyper=0x%X",
+           keymapWrapper, keymapWrapper->GetModifierMask(CAPS_LOCK),
+           keymapWrapper->GetModifierMask(NUM_LOCK),
+           keymapWrapper->GetModifierMask(SCROLL_LOCK),
+           keymapWrapper->GetModifierMask(LEVEL3),
+           keymapWrapper->GetModifierMask(LEVEL5),
+           keymapWrapper->GetModifierMask(SHIFT),
+           keymapWrapper->GetModifierMask(CTRL),
+           keymapWrapper->GetModifierMask(ALT),
+           keymapWrapper->GetModifierMask(META),
+           keymapWrapper->GetModifierMask(SUPER),
+           keymapWrapper->GetModifierMask(HYPER)));
+}
+
+/* This keymap routine is derived from weston-2.0.0/clients/simple-im.c
+ */
+static void keyboard_handle_keymap(void* data, struct wl_keyboard* wl_keyboard,
+                                   uint32_t format, int fd, uint32_t size) {
+  KeymapWrapper::ResetKeyboard();
+
+  if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
+    close(fd);
+    return;
+  }
+
+  char* mapString = (char*)mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
+  if (mapString == MAP_FAILED) {
+    close(fd);
+    return;
+  }
+
+  static auto sXkbContextNew =
+      (struct xkb_context * (*)(enum xkb_context_flags))
+          dlsym(RTLD_DEFAULT, "xkb_context_new");
+  static auto sXkbKeymapNewFromString =
+      (struct xkb_keymap * (*)(struct xkb_context*, const char*,
+                               enum xkb_keymap_format,
+                               enum xkb_keymap_compile_flags))
+          dlsym(RTLD_DEFAULT, "xkb_keymap_new_from_string");
+
+  struct xkb_context* xkb_context = sXkbContextNew(XKB_CONTEXT_NO_FLAGS);
+  struct xkb_keymap* keymap =
+      sXkbKeymapNewFromString(xkb_context, mapString, XKB_KEYMAP_FORMAT_TEXT_V1,
+                              XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+  munmap(mapString, size);
+  close(fd);
+
+  if (!keymap) {
+    NS_WARNING("keyboard_handle_keymap(): Failed to compile keymap!\n");
+    return;
+  }
+
+  KeymapWrapper::SetModifierMasks(keymap);
+
+  static auto sXkbKeymapUnRef =
+      (void (*)(struct xkb_keymap*))dlsym(RTLD_DEFAULT, "xkb_keymap_unref");
+  sXkbKeymapUnRef(keymap);
+
+  static auto sXkbContextUnref =
+      (void (*)(struct xkb_context*))dlsym(RTLD_DEFAULT, "xkb_context_unref");
+  sXkbContextUnref(xkb_context);
+}
+
+static void keyboard_handle_enter(void* data, struct wl_keyboard* keyboard,
+                                  uint32_t serial, struct wl_surface* surface,
+                                  struct wl_array* keys) {
+  KeymapWrapper::SetFocusIn(surface, serial);
+}
+
+static void keyboard_handle_leave(void* data, struct wl_keyboard* keyboard,
+                                  uint32_t serial, struct wl_surface* surface) {
+  KeymapWrapper::SetFocusOut(surface);
+}
+
+static void keyboard_handle_key(void* data, struct wl_keyboard* keyboard,
+                                uint32_t serial, uint32_t time, uint32_t key,
+                                uint32_t state) {}
+static void keyboard_handle_modifiers(void* data, struct wl_keyboard* keyboard,
+                                      uint32_t serial, uint32_t mods_depressed,
+                                      uint32_t mods_latched,
+                                      uint32_t mods_locked, uint32_t group) {}
+
+static const struct wl_keyboard_listener keyboard_listener = {
+    keyboard_handle_keymap, keyboard_handle_enter,     keyboard_handle_leave,
+    keyboard_handle_key,    keyboard_handle_modifiers,
+};
+
+static void seat_handle_capabilities(void* data, struct wl_seat* seat,
+                                     unsigned int caps) {
+  static wl_keyboard* keyboard = nullptr;
+
+  if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !keyboard) {
+    keyboard = wl_seat_get_keyboard(seat);
+    wl_keyboard_add_listener(keyboard, &keyboard_listener, nullptr);
+  } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && keyboard) {
+    wl_keyboard_destroy(keyboard);
+    keyboard = nullptr;
+  }
+}
+
+static const struct wl_seat_listener seat_listener = {
+    seat_handle_capabilities,
+};
+
+static void gdk_registry_handle_global(void* data, struct wl_registry* registry,
+                                       uint32_t id, const char* interface,
+                                       uint32_t version) {
+  if (strcmp(interface, "wl_seat") == 0) {
+    auto* seat =
+        WaylandRegistryBind<wl_seat>(registry, id, &wl_seat_interface, 1);
+    KeymapWrapper::SetSeat(seat);
+    wl_seat_add_listener(seat, &seat_listener, data);
+  }
+}
+
+static void gdk_registry_handle_global_remove(void* data,
+                                              struct wl_registry* registry,
+                                              uint32_t id) {}
+
+static const struct wl_registry_listener keyboard_registry_listener = {
+    gdk_registry_handle_global, gdk_registry_handle_global_remove};
+
+void KeymapWrapper::InitBySystemSettingsWayland() {
+  wl_display* display = WaylandDisplayGetWLDisplay();
+  wl_registry_add_listener(wl_display_get_registry(display),
+                           &keyboard_registry_listener, this);
+}
+#endif
+
+KeymapWrapper::~KeymapWrapper() {
+#ifdef MOZ_X11
+  gdk_window_remove_filter(nullptr, FilterEvents, this);
+#endif
+  if (mOnKeysChangedSignalHandle) {
+    g_signal_handler_disconnect(mGdkKeymap, mOnKeysChangedSignalHandle);
+  }
+  if (mOnDirectionChangedSignalHandle) {
+    g_signal_handler_disconnect(mGdkKeymap, mOnDirectionChangedSignalHandle);
+  }
+  g_object_unref(mGdkKeymap);
+  MOZ_LOG(gKeyLog, LogLevel::Info, ("%p Destructor", this));
+}
+
+#ifdef MOZ_X11
+/* static */
+GdkFilterReturn KeymapWrapper::FilterEvents(GdkXEvent* aXEvent,
+                                            GdkEvent* aGdkEvent,
+                                            gpointer aData) {
+  XEvent* xEvent = static_cast<XEvent*>(aXEvent);
+  switch (xEvent->type) {
+    case KeyPress: {
+      // If the key doesn't support auto repeat, ignore the event because
+      // even if such key (e.g., Shift) is pressed during auto repeat of
+      // anoter key, it doesn't stop the auto repeat.
+      KeymapWrapper* self = static_cast<KeymapWrapper*>(aData);
+      if (!self->IsAutoRepeatableKey(xEvent->xkey.keycode)) {
+        break;
+      }
+      if (sRepeatState == NOT_PRESSED) {
+        sRepeatState = FIRST_PRESS;
+        MOZ_LOG(gKeyLog, LogLevel::Info,
+                ("FilterEvents(aXEvent={ type=KeyPress, "
+                 "xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
+                 "aGdkEvent={ state=0x%08X }), "
+                 "detected first keypress",
+                 xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
+                 reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
+      } else if (sLastRepeatableHardwareKeyCode == xEvent->xkey.keycode) {
+        if (sLastRepeatableKeyTime == xEvent->xkey.time &&
+            sLastRepeatableHardwareKeyCode ==
+                IMContextWrapper::
+                    GetWaitingSynthesizedKeyPressHardwareKeyCode()) {
+          // On some environment, IM may generate duplicated KeyPress event
+          // without any special state flags.  In such case, we shouldn't
+          // treat the event as "repeated".
+          MOZ_LOG(gKeyLog, LogLevel::Info,
+                  ("FilterEvents(aXEvent={ type=KeyPress, "
+                   "xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
+                   "aGdkEvent={ state=0x%08X }), "
+                   "igored keypress since it must be synthesized by IME",
+                   xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
+                   reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
+          break;
+        }
+        sRepeatState = REPEATING;
+        MOZ_LOG(gKeyLog, LogLevel::Info,
+                ("FilterEvents(aXEvent={ type=KeyPress, "
+                 "xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
+                 "aGdkEvent={ state=0x%08X }), "
+                 "detected repeating keypress",
+                 xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
+                 reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
+      } else {
+        // If a different key is pressed while another key is pressed,
+        // auto repeat system repeats only the last pressed key.
+        // So, setting new keycode and setting repeat state as first key
+        // press should work fine.
+        sRepeatState = FIRST_PRESS;
+        MOZ_LOG(gKeyLog, LogLevel::Info,
+                ("FilterEvents(aXEvent={ type=KeyPress, "
+                 "xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
+                 "aGdkEvent={ state=0x%08X }), "
+                 "detected different keypress",
+                 xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
+                 reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
+      }
+      sLastRepeatableHardwareKeyCode = xEvent->xkey.keycode;
+      sLastRepeatableKeyTime = xEvent->xkey.time;
+      break;
+    }
+    case KeyRelease: {
+      if (sLastRepeatableHardwareKeyCode != xEvent->xkey.keycode) {
+        // This case means the key release event is caused by
+        // a non-repeatable key such as Shift or a repeatable key that
+        // was pressed before sLastRepeatableHardwareKeyCode was
+        // pressed.
+        break;
+      }
+      sRepeatState = NOT_PRESSED;
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("FilterEvents(aXEvent={ type=KeyRelease, "
+               "xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
+               "aGdkEvent={ state=0x%08X }), "
+               "detected key release",
+               xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
+               reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
+      break;
+    }
+    case FocusOut: {
+      // At moving focus, we should reset keyboard repeat state.
+      // Strictly, this causes incorrect behavior.  However, this
+      // correctness must be enough for web applications.
+      sRepeatState = NOT_PRESSED;
+      break;
+    }
+    default: {
+      KeymapWrapper* self = static_cast<KeymapWrapper*>(aData);
+      if (xEvent->type != self->mXKBBaseEventCode) {
+        break;
+      }
+      XkbEvent* xkbEvent = (XkbEvent*)xEvent;
+      if (xkbEvent->any.xkb_type != XkbControlsNotify ||
+          !(xkbEvent->ctrls.changed_ctrls & XkbPerKeyRepeatMask)) {
+        break;
+      }
+      if (!XGetKeyboardControl(xkbEvent->any.display, &self->mKeyboardState)) {
+        MOZ_LOG(gKeyLog, LogLevel::Info,
+                ("%p FilterEvents failed due to failure "
+                 "of XGetKeyboardControl(), display=0x%p",
+                 self, xkbEvent->any.display));
+      }
+      break;
+    }
+  }
+
+  return GDK_FILTER_CONTINUE;
+}
+#endif
+
+static void ResetBidiKeyboard() {
+  // Reset the bidi keyboard settings for the new GdkKeymap
+  nsCOMPtr<nsIBidiKeyboard> bidiKeyboard = nsContentUtils::GetBidiKeyboard();
+  if (bidiKeyboard) {
+    bidiKeyboard->Reset();
+  }
+  WidgetUtils::SendBidiKeyboardInfoToContent();
+}
+
+/* static */
+void KeymapWrapper::ResetKeyboard() {
+  sInstance->mInitialized = false;
+  ResetBidiKeyboard();
+}
+
+/* static */
+void KeymapWrapper::OnKeysChanged(GdkKeymap* aGdkKeymap,
+                                  KeymapWrapper* aKeymapWrapper) {
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("OnKeysChanged, aGdkKeymap=%p, aKeymapWrapper=%p", aGdkKeymap,
+           aKeymapWrapper));
+
+  MOZ_ASSERT(sInstance == aKeymapWrapper,
+             "This instance must be the singleton instance");
+
+  // We cannot reintialize here becasue we don't have GdkWindow which is using
+  // the GdkKeymap.  We'll reinitialize it when next GetInstance() is called.
+  ResetKeyboard();
+}
+
+// static
+void KeymapWrapper::OnDirectionChanged(GdkKeymap* aGdkKeymap,
+                                       KeymapWrapper* aKeymapWrapper) {
+  // XXX
+  // A lot of diretion-changed signal might be fired on switching bidi
+  // keyboard when using both ibus (with arabic layout) and fcitx (with IME).
+  // See https://github.com/fcitx/fcitx/issues/257
+  //
+  // Also, when using ibus, switching to IM might not cause this signal.
+  // See https://github.com/ibus/ibus/issues/1848
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("OnDirectionChanged, aGdkKeymap=%p, aKeymapWrapper=%p", aGdkKeymap,
+           aKeymapWrapper));
+
+  ResetBidiKeyboard();
+}
+
+/* static */
+guint KeymapWrapper::GetCurrentModifierState() {
+  GdkModifierType modifiers;
+  GdkDisplay* display = gdk_display_get_default();
+  GdkScreen* screen = gdk_display_get_default_screen(display);
+  GdkWindow* window = gdk_screen_get_root_window(screen);
+  gdk_window_get_device_position(window, GdkGetPointer(), nullptr, nullptr,
+                                 &modifiers);
+  return static_cast<guint>(modifiers);
+}
+
+/* static */
+bool KeymapWrapper::AreModifiersCurrentlyActive(Modifiers aModifiers) {
+  guint modifierState = GetCurrentModifierState();
+  return AreModifiersActive(aModifiers, modifierState);
+}
+
+/* static */
+bool KeymapWrapper::AreModifiersActive(Modifiers aModifiers,
+                                       guint aModifierState) {
+  NS_ENSURE_TRUE(aModifiers, false);
+
+  KeymapWrapper* keymapWrapper = GetInstance();
+  for (uint32_t i = 0; i < sizeof(Modifier) * 8 && aModifiers; i++) {
+    Modifier modifier = static_cast<Modifier>(1 << i);
+    if (!(aModifiers & modifier)) {
+      continue;
+    }
+    if (!(aModifierState & keymapWrapper->GetModifierMask(modifier))) {
+      return false;
+    }
+    aModifiers &= ~modifier;
+  }
+  return true;
+}
+
+/* static */
+uint32_t KeymapWrapper::ComputeCurrentKeyModifiers() {
+  return ComputeKeyModifiers(GetCurrentModifierState());
+}
+
+/* static */
+uint32_t KeymapWrapper::ComputeKeyModifiers(guint aModifierState) {
+  KeymapWrapper* keymapWrapper = GetInstance();
+
+  uint32_t keyModifiers = 0;
+  // DOM Meta key should be TRUE only on Mac.  We need to discuss this
+  // issue later.
+  if (keymapWrapper->AreModifiersActive(SHIFT, aModifierState)) {
+    keyModifiers |= MODIFIER_SHIFT;
+  }
+  if (keymapWrapper->AreModifiersActive(CTRL, aModifierState)) {
+    keyModifiers |= MODIFIER_CONTROL;
+  }
+  if (keymapWrapper->AreModifiersActive(ALT, aModifierState)) {
+    keyModifiers |= MODIFIER_ALT;
+  }
+  if (keymapWrapper->AreModifiersActive(META, aModifierState)) {
+    keyModifiers |= MODIFIER_META;
+  }
+  if (keymapWrapper->AreModifiersActive(SUPER, aModifierState) ||
+      keymapWrapper->AreModifiersActive(HYPER, aModifierState)) {
+    keyModifiers |= MODIFIER_OS;
+  }
+  if (keymapWrapper->AreModifiersActive(LEVEL3, aModifierState) ||
+      keymapWrapper->AreModifiersActive(LEVEL5, aModifierState)) {
+    keyModifiers |= MODIFIER_ALTGRAPH;
+  }
+  if (keymapWrapper->AreModifiersActive(CAPS_LOCK, aModifierState)) {
+    keyModifiers |= MODIFIER_CAPSLOCK;
+  }
+  if (keymapWrapper->AreModifiersActive(NUM_LOCK, aModifierState)) {
+    keyModifiers |= MODIFIER_NUMLOCK;
+  }
+  if (keymapWrapper->AreModifiersActive(SCROLL_LOCK, aModifierState)) {
+    keyModifiers |= MODIFIER_SCROLLLOCK;
+  }
+  return keyModifiers;
+}
+
+/* static */
+guint KeymapWrapper::ConvertWidgetModifierToGdkState(
+    nsIWidget::Modifiers aNativeModifiers) {
+  if (!aNativeModifiers) {
+    return 0;
+  }
+  struct ModifierMapEntry {
+    nsIWidget::Modifiers mWidgetModifier;
+    Modifier mModifier;
+  };
+  // TODO: Currently, we don't treat L/R of each modifier on Linux.
+  // TODO: No proper native modifier for Level5.
+  static constexpr ModifierMapEntry sModifierMap[] = {
+      {nsIWidget::CAPS_LOCK, Modifier::CAPS_LOCK},
+      {nsIWidget::NUM_LOCK, Modifier::NUM_LOCK},
+      {nsIWidget::SHIFT_L, Modifier::SHIFT},
+      {nsIWidget::SHIFT_R, Modifier::SHIFT},
+      {nsIWidget::CTRL_L, Modifier::CTRL},
+      {nsIWidget::CTRL_R, Modifier::CTRL},
+      {nsIWidget::ALT_L, Modifier::ALT},
+      {nsIWidget::ALT_R, Modifier::ALT},
+      {nsIWidget::ALTGRAPH, Modifier::LEVEL3},
+      {nsIWidget::COMMAND_L, Modifier::SUPER},
+      {nsIWidget::COMMAND_R, Modifier::SUPER}};
+
+  guint state = 0;
+  KeymapWrapper* instance = GetInstance();
+  for (const ModifierMapEntry& entry : sModifierMap) {
+    if (aNativeModifiers & entry.mWidgetModifier) {
+      state |= instance->GetModifierMask(entry.mModifier);
+    }
+  }
+  return state;
+}
+
+/* static */
+void KeymapWrapper::InitInputEvent(WidgetInputEvent& aInputEvent,
+                                   guint aModifierState) {
+  KeymapWrapper* keymapWrapper = GetInstance();
+
+  aInputEvent.mModifiers = ComputeKeyModifiers(aModifierState);
+
+  // Don't log this method for non-important events because e.g., eMouseMove is
+  // just noisy and there is no reason to log it.
+  bool doLog = aInputEvent.mMessage != eMouseMove;
+  if (doLog) {
+    MOZ_LOG(gKeyLog, LogLevel::Debug,
+            ("%p InitInputEvent, aModifierState=0x%08X, "
+             "aInputEvent={ mMessage=%s, mModifiers=0x%04X (Shift: %s, "
+             "Control: %s, Alt: %s, "
+             "Meta: %s, OS: %s, AltGr: %s, "
+             "CapsLock: %s, NumLock: %s, ScrollLock: %s })",
+             keymapWrapper, aModifierState, ToChar(aInputEvent.mMessage),
+             aInputEvent.mModifiers,
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_SHIFT),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_CONTROL),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_ALT),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_META),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_OS),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_ALTGRAPH),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_CAPSLOCK),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_NUMLOCK),
+             GetBoolName(aInputEvent.mModifiers & MODIFIER_SCROLLLOCK)));
+  }
+
+  switch (aInputEvent.mClass) {
+    case eMouseEventClass:
+    case eMouseScrollEventClass:
+    case eWheelEventClass:
+    case eDragEventClass:
+    case eSimpleGestureEventClass:
+      break;
+    default:
+      return;
+  }
+
+  WidgetMouseEventBase& mouseEvent = *aInputEvent.AsMouseEventBase();
+  mouseEvent.mButtons = 0;
+  if (aModifierState & GDK_BUTTON1_MASK) {
+    mouseEvent.mButtons |= MouseButtonsFlag::ePrimaryFlag;
+  }
+  if (aModifierState & GDK_BUTTON3_MASK) {
+    mouseEvent.mButtons |= MouseButtonsFlag::eSecondaryFlag;
+  }
+  if (aModifierState & GDK_BUTTON2_MASK) {
+    mouseEvent.mButtons |= MouseButtonsFlag::eMiddleFlag;
+  }
+
+  if (doLog) {
+    MOZ_LOG(
+        gKeyLog, LogLevel::Debug,
+        ("%p   InitInputEvent, aInputEvent has mButtons, "
+         "aInputEvent.mButtons=0x%04X (Left: %s, Right: %s, Middle: %s, "
+         "4th (BACK): %s, 5th (FORWARD): %s)",
+         keymapWrapper, mouseEvent.mButtons,
+         GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::ePrimaryFlag),
+         GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::eSecondaryFlag),
+         GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::eMiddleFlag),
+         GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::e4thFlag),
+         GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::e5thFlag)));
+  }
+}
+
+/* static */
+uint32_t KeymapWrapper::ComputeDOMKeyCode(const GdkEventKey* aGdkKeyEvent) {
+  // If the keyval indicates it's a modifier key, we should use unshifted
+  // key's modifier keyval.
+  guint keyval = aGdkKeyEvent->keyval;
+  if (GetModifierForGDKKeyval(keyval)) {
+    // But if the keyval without modifiers isn't a modifier key, we
+    // shouldn't use it.  E.g., Japanese keyboard layout's
+    // Shift + Eisu-Toggle key is CapsLock.  This is an actual rare case,
+    // Windows uses different keycode for a physical key for different
+    // shift key state.
+    guint keyvalWithoutModifier = GetGDKKeyvalWithoutModifier(aGdkKeyEvent);
+    if (GetModifierForGDKKeyval(keyvalWithoutModifier)) {
+      keyval = keyvalWithoutModifier;
+    }
+    // Note that the modifier keycode and activating or deactivating
+    // modifier flag may be mismatched, but it's okay.  If a DOM key
+    // event handler is testing a keydown event, it's more likely being
+    // used to test which key is being pressed than to test which
+    // modifier will become active.  So, if we computed DOM keycode
+    // from modifier flag which were changing by the physical key, then
+    // there would be no other way for the user to generate the original
+    // keycode.
+    uint32_t DOMKeyCode = GetDOMKeyCodeFromKeyPairs(keyval);
+    NS_ASSERTION(DOMKeyCode, "All modifier keys must have a DOM keycode");
+    return DOMKeyCode;
+  }
+
+  // If the key isn't printable, let's look at the key pairs.
+  uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
+  if (!charCode) {
+    // Note that any key may be a function key because of some unusual keyboard
+    // layouts.  I.e., even if the pressed key is a printable key of en-US
+    // keyboard layout, we should expose the function key's keyCode value to
+    // web apps because web apps should handle the keydown/keyup events as
+    // inputted by usual keyboard layout.  For example, Hatchak keyboard
+    // maps Tab key to "Digit3" key and Level3 Shift makes it "Backspace".
+    // In this case, we should expose DOM_VK_BACK_SPACE (8).
+    uint32_t DOMKeyCode = GetDOMKeyCodeFromKeyPairs(keyval);
+    if (DOMKeyCode) {
+      // XXX If DOMKeyCode is a function key's keyCode value, it might be
+      //     better to consume necessary modifiers.  For example, if there is
+      //     no Control Pad section on keyboard like notebook, Delete key is
+      //     available only with Level3 Shift+"Backspace" key if using Hatchak.
+      //     If web apps accept Delete key operation only when no modifiers are
+      //     active, such users cannot use Delete key to do it.  However,
+      //     Chromium doesn't consume such necessary modifiers.  So, our default
+      //     behavior should keep not touching modifiers for compatibility, but
+      //     it might be better to add a pref to consume necessary modifiers.
+      return DOMKeyCode;
+    }
+    // If aGdkKeyEvent cannot be mapped to a DOM keyCode value, we should
+    // refer keyCode value without modifiers because web apps should be
+    // able to identify the key as far as possible.
+    guint keyvalWithoutModifier = GetGDKKeyvalWithoutModifier(aGdkKeyEvent);
+    return GetDOMKeyCodeFromKeyPairs(keyvalWithoutModifier);
+  }
+
+  // printable numpad keys should be resolved here.
+  switch (keyval) {
+    case GDK_KP_Multiply:
+      return NS_VK_MULTIPLY;
+    case GDK_KP_Add:
+      return NS_VK_ADD;
+    case GDK_KP_Separator:
+      return NS_VK_SEPARATOR;
+    case GDK_KP_Subtract:
+      return NS_VK_SUBTRACT;
+    case GDK_KP_Decimal:
+      return NS_VK_DECIMAL;
+    case GDK_KP_Divide:
+      return NS_VK_DIVIDE;
+    case GDK_KP_0:
+      return NS_VK_NUMPAD0;
+    case GDK_KP_1:
+      return NS_VK_NUMPAD1;
+    case GDK_KP_2:
+      return NS_VK_NUMPAD2;
+    case GDK_KP_3:
+      return NS_VK_NUMPAD3;
+    case GDK_KP_4:
+      return NS_VK_NUMPAD4;
+    case GDK_KP_5:
+      return NS_VK_NUMPAD5;
+    case GDK_KP_6:
+      return NS_VK_NUMPAD6;
+    case GDK_KP_7:
+      return NS_VK_NUMPAD7;
+    case GDK_KP_8:
+      return NS_VK_NUMPAD8;
+    case GDK_KP_9:
+      return NS_VK_NUMPAD9;
+  }
+
+  KeymapWrapper* keymapWrapper = GetInstance();
+
+  // Ignore all modifier state except NumLock.
+  guint baseState =
+      (aGdkKeyEvent->state & keymapWrapper->GetModifierMask(NUM_LOCK));
+
+  // Basically, we should use unmodified character for deciding our keyCode.
+  uint32_t unmodifiedChar = keymapWrapper->GetCharCodeFor(
+      aGdkKeyEvent, baseState, aGdkKeyEvent->group);
+  if (IsBasicLatinLetterOrNumeral(unmodifiedChar)) {
+    // If the unmodified character is an ASCII alphabet or an ASCII
+    // numeric, it's the best hint for deciding our keyCode.
+    return WidgetUtils::ComputeKeyCodeFromChar(unmodifiedChar);
+  }
+
+  // If the unmodified character is not an ASCII character, that means we
+  // couldn't find the hint. We should reset it.
+  if (!IsPrintableASCIICharacter(unmodifiedChar)) {
+    unmodifiedChar = 0;
+  }
+
+  // Retry with shifted keycode.
+  guint shiftState = (baseState | keymapWrapper->GetModifierMask(SHIFT));
+  uint32_t shiftedChar = keymapWrapper->GetCharCodeFor(aGdkKeyEvent, shiftState,
+                                                       aGdkKeyEvent->group);
+  if (IsBasicLatinLetterOrNumeral(shiftedChar)) {
+    // A shifted character can be an ASCII alphabet on Hebrew keyboard
+    // layout. And also shifted character can be an ASCII numeric on
+    // AZERTY keyboad layout.  Then, it's a good hint for deciding our
+    // keyCode.
+    return WidgetUtils::ComputeKeyCodeFromChar(shiftedChar);
+  }
+
+  // If the shifted unmodified character isn't an ASCII character, we should
+  // discard it too.
+  if (!IsPrintableASCIICharacter(shiftedChar)) {
+    shiftedChar = 0;
+  }
+
+  // If current keyboard layout isn't ASCII alphabet inputtable layout,
+  // look for ASCII alphabet inputtable keyboard layout.  If the key
+  // inputs an ASCII alphabet or an ASCII numeric, we should use it
+  // for deciding our keyCode.
+  uint32_t unmodCharLatin = 0;
+  uint32_t shiftedCharLatin = 0;
+  if (!keymapWrapper->IsLatinGroup(aGdkKeyEvent->group)) {
+    gint minGroup = keymapWrapper->GetFirstLatinGroup();
+    if (minGroup >= 0) {
+      unmodCharLatin =
+          keymapWrapper->GetCharCodeFor(aGdkKeyEvent, baseState, minGroup);
+      if (IsBasicLatinLetterOrNumeral(unmodCharLatin)) {
+        // If the unmodified character is an ASCII alphabet or
+        // an ASCII numeric, we should use it for the keyCode.
+        return WidgetUtils::ComputeKeyCodeFromChar(unmodCharLatin);
+      }
+      // If the unmodified character in the alternative ASCII capable
+      // keyboard layout isn't an ASCII character, that means we couldn't
+      // find the hint. We should reset it.
+      if (!IsPrintableASCIICharacter(unmodCharLatin)) {
+        unmodCharLatin = 0;
+      }
+      shiftedCharLatin =
+          keymapWrapper->GetCharCodeFor(aGdkKeyEvent, shiftState, minGroup);
+      if (IsBasicLatinLetterOrNumeral(shiftedCharLatin)) {
+        // If the shifted character is an ASCII alphabet or an ASCII
+        // numeric, we should use it for the keyCode.
+        return WidgetUtils::ComputeKeyCodeFromChar(shiftedCharLatin);
+      }
+      // If the shifted unmodified character in the alternative ASCII
+      // capable keyboard layout isn't an ASCII character, we should
+      // discard it too.
+      if (!IsPrintableASCIICharacter(shiftedCharLatin)) {
+        shiftedCharLatin = 0;
+      }
+    }
+  }
+
+  // If the key itself or with Shift state on active keyboard layout produces
+  // an ASCII punctuation character, we should decide keyCode value with it.
+  if (unmodifiedChar || shiftedChar) {
+    return WidgetUtils::ComputeKeyCodeFromChar(unmodifiedChar ? unmodifiedChar
+                                                              : shiftedChar);
+  }
+
+  // If the key itself or with Shift state on alternative ASCII capable
+  // keyboard layout produces an ASCII punctuation character, we should
+  // decide keyCode value with it.  Note that We've returned 0 for long
+  // time if keyCode isn't for an alphabet keys or a numeric key even in
+  // alternative ASCII capable keyboard layout because we decided that we
+  // should avoid setting same keyCode value to 2 or more keys since active
+  // keyboard layout may have a key to input the punctuation with different
+  // key.  However, setting keyCode to 0 makes some web applications which
+  // are aware of neither KeyboardEvent.key nor KeyboardEvent.code not work
+  // with Firefox when user selects non-ASCII capable keyboard layout such
+  // as Russian and Thai.  So, if alternative ASCII capable keyboard layout
+  // has keyCode value for the key, we should use it.  In other words, this
+  // behavior means that non-ASCII capable keyboard layout overrides some
+  // keys' keyCode value only if the key produces ASCII character by itself
+  // or with Shift key.
+  if (unmodCharLatin || shiftedCharLatin) {
+    return WidgetUtils::ComputeKeyCodeFromChar(
+        unmodCharLatin ? unmodCharLatin : shiftedCharLatin);
+  }
+
+  // Otherwise, let's decide keyCode value from the hardware_keycode
+  // value on major keyboard layout.
+  CodeNameIndex code = ComputeDOMCodeNameIndex(aGdkKeyEvent);
+  return WidgetKeyboardEvent::GetFallbackKeyCodeOfPunctuationKey(code);
+}
+
+KeyNameIndex KeymapWrapper::ComputeDOMKeyNameIndex(
+    const GdkEventKey* aGdkKeyEvent) {
+  switch (aGdkKeyEvent->keyval) {
+#define NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX(aNativeKey, aKeyNameIndex) \
+  case aNativeKey:                                                     \
+    return aKeyNameIndex;
+
+#include "NativeKeyToDOMKeyName.h"
+
+#undef NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX
+
+    default:
+      break;
+  }
+
+  return KEY_NAME_INDEX_Unidentified;
+}
+
+/* static */
+CodeNameIndex KeymapWrapper::ComputeDOMCodeNameIndex(
+    const GdkEventKey* aGdkKeyEvent) {
+  switch (aGdkKeyEvent->hardware_keycode) {
+#define NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, aCodeNameIndex) \
+  case aNativeKey:                                                       \
+    return aCodeNameIndex;
+
+#include "NativeKeyToDOMCodeName.h"
+
+#undef NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX
+
+    default:
+      break;
+  }
+
+  return CODE_NAME_INDEX_UNKNOWN;
+}
+
+/* static */
+bool KeymapWrapper::DispatchKeyDownOrKeyUpEvent(nsWindow* aWindow,
+                                                GdkEventKey* aGdkKeyEvent,
+                                                bool aIsProcessedByIME,
+                                                bool* aIsCancelled) {
+  MOZ_ASSERT(aIsCancelled, "aIsCancelled must not be nullptr");
+
+  *aIsCancelled = false;
+
+  if (aGdkKeyEvent->type == GDK_KEY_PRESS && aGdkKeyEvent->keyval == GDK_Tab &&
+      AreModifiersActive(CTRL | ALT, aGdkKeyEvent->state)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("  DispatchKeyDownOrKeyUpEvent(), didn't dispatch keyboard events "
+             "because it's Ctrl + Alt + Tab"));
+    return false;
+  }
+
+  EventMessage message =
+      aGdkKeyEvent->type == GDK_KEY_PRESS ? eKeyDown : eKeyUp;
+  WidgetKeyboardEvent keyEvent(true, message, aWindow);
+  KeymapWrapper::InitKeyEvent(keyEvent, aGdkKeyEvent, aIsProcessedByIME);
+  return DispatchKeyDownOrKeyUpEvent(aWindow, keyEvent, aIsCancelled);
+}
+
+/* static */
+bool KeymapWrapper::DispatchKeyDownOrKeyUpEvent(
+    nsWindow* aWindow, WidgetKeyboardEvent& aKeyboardEvent,
+    bool* aIsCancelled) {
+  MOZ_ASSERT(aIsCancelled, "aIsCancelled must not be nullptr");
+
+  *aIsCancelled = false;
+
+  RefPtr<TextEventDispatcher> dispatcher = aWindow->GetTextEventDispatcher();
+  nsresult rv = dispatcher->BeginNativeInputTransaction();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_LOG(gKeyLog, LogLevel::Error,
+            ("  DispatchKeyDownOrKeyUpEvent(), stopped dispatching %s event "
+             "because of failed to initialize TextEventDispatcher",
+             ToChar(aKeyboardEvent.mMessage)));
+    return FALSE;
+  }
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  bool dispatched = dispatcher->DispatchKeyboardEvent(
+      aKeyboardEvent.mMessage, aKeyboardEvent, status, nullptr);
+  *aIsCancelled = (status == nsEventStatus_eConsumeNoDefault);
+  return dispatched;
+}
+
+/* static */
+bool KeymapWrapper::MaybeDispatchContextMenuEvent(nsWindow* aWindow,
+                                                  const GdkEventKey* aEvent) {
+  KeyNameIndex keyNameIndex = ComputeDOMKeyNameIndex(aEvent);
+
+  // Shift+F10 and ContextMenu should cause eContextMenu event.
+  if (keyNameIndex != KEY_NAME_INDEX_F10 &&
+      keyNameIndex != KEY_NAME_INDEX_ContextMenu) {
+    return false;
+  }
+
+  WidgetMouseEvent contextMenuEvent(true, eContextMenu, aWindow,
+                                    WidgetMouseEvent::eReal,
+                                    WidgetMouseEvent::eContextMenuKey);
+
+  contextMenuEvent.mRefPoint = LayoutDeviceIntPoint(0, 0);
+  contextMenuEvent.AssignEventTime(aWindow->GetWidgetEventTime(aEvent->time));
+  contextMenuEvent.mClickCount = 1;
+  KeymapWrapper::InitInputEvent(contextMenuEvent, aEvent->state);
+
+  if (contextMenuEvent.IsControl() || contextMenuEvent.IsMeta() ||
+      contextMenuEvent.IsAlt()) {
+    return false;
+  }
+
+  // If the key is ContextMenu, then an eContextMenu mouse event is
+  // dispatched regardless of the state of the Shift modifier.  When it is
+  // pressed without the Shift modifier, a web page can prevent the default
+  // context menu action.  When pressed with the Shift modifier, the web page
+  // cannot prevent the default context menu action.
+  // (PresShell::HandleEventInternal() sets mOnlyChromeDispatch to true.)
+
+  // If the key is F10, it needs Shift state because Shift+F10 is well-known
+  // shortcut key on Linux.  However, eContextMenu with Shift state is
+  // special.  It won't fire "contextmenu" event in the web content for
+  // blocking web page to prevent its default.  Therefore, this combination
+  // should work same as ContextMenu key.
+  // XXX Should we allow to block web page to prevent its default with
+  //     Ctrl+Shift+F10 or Alt+Shift+F10 instead?
+  if (keyNameIndex == KEY_NAME_INDEX_F10) {
+    if (!contextMenuEvent.IsShift()) {
+      return false;
+    }
+    contextMenuEvent.mModifiers &= ~MODIFIER_SHIFT;
+  }
+
+  aWindow->DispatchInputEvent(&contextMenuEvent);
+  return true;
+}
+
+/* static*/
+void KeymapWrapper::HandleKeyPressEvent(nsWindow* aWindow,
+                                        GdkEventKey* aGdkKeyEvent) {
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("HandleKeyPressEvent(aWindow=%p, aGdkKeyEvent={ type=%s, "
+           "keyval=%s(0x%X), state=0x%08X, hardware_keycode=0x%08X, "
+           "time=%u, is_modifier=%s })",
+           aWindow,
+           ((aGdkKeyEvent->type == GDK_KEY_PRESS) ? "GDK_KEY_PRESS"
+                                                  : "GDK_KEY_RELEASE"),
+           gdk_keyval_name(aGdkKeyEvent->keyval), aGdkKeyEvent->keyval,
+           aGdkKeyEvent->state, aGdkKeyEvent->hardware_keycode,
+           aGdkKeyEvent->time, GetBoolName(aGdkKeyEvent->is_modifier)));
+
+  // if we are in the middle of composing text, XIM gets to see it
+  // before mozilla does.
+  // FYI: Don't dispatch keydown event before notifying IME of the event
+  //      because IME may send a key event synchronously and consume the
+  //      original event.
+  bool IMEWasEnabled = false;
+  KeyHandlingState handlingState = KeyHandlingState::eNotHandled;
+  RefPtr<IMContextWrapper> imContext = aWindow->GetIMContext();
+  if (imContext) {
+    IMEWasEnabled = imContext->IsEnabled();
+    handlingState = imContext->OnKeyEvent(aWindow, aGdkKeyEvent);
+    if (handlingState == KeyHandlingState::eHandled) {
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), the event was handled by "
+               "IMContextWrapper"));
+      return;
+    }
+  }
+
+  // work around for annoying things.
+  if (aGdkKeyEvent->keyval == GDK_Tab &&
+      AreModifiersActive(CTRL | ALT, aGdkKeyEvent->state)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("  HandleKeyPressEvent(), didn't dispatch keyboard events "
+             "because it's Ctrl + Alt + Tab"));
+    return;
+  }
+
+  // Dispatch keydown event always.  At auto repeating, we should send
+  // KEYDOWN -> KEYPRESS -> KEYDOWN -> KEYPRESS ... -> KEYUP
+  // However, old distributions (e.g., Ubuntu 9.10) sent native key
+  // release event, so, on such platform, the DOM events will be:
+  // KEYDOWN -> KEYPRESS -> KEYUP -> KEYDOWN -> KEYPRESS -> KEYUP...
+
+  bool isKeyDownCancelled = false;
+  if (handlingState == KeyHandlingState::eNotHandled) {
+    if (DispatchKeyDownOrKeyUpEvent(aWindow, aGdkKeyEvent, false,
+                                    &isKeyDownCancelled) &&
+        (MOZ_UNLIKELY(aWindow->IsDestroyed()) || isKeyDownCancelled)) {
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched eKeyDown event and "
+               "stopped handling the event because %s",
+               aWindow->IsDestroyed() ? "the window has been destroyed"
+                                      : "the event was consumed"));
+      return;
+    }
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("  HandleKeyPressEvent(), dispatched eKeyDown event and "
+             "it wasn't consumed"));
+    handlingState = KeyHandlingState::eNotHandledButEventDispatched;
+  }
+
+  // If a keydown event handler causes to enable IME, i.e., it moves
+  // focus from IME unusable content to IME usable editor, we should
+  // send the native key event to IME for the first input on the editor.
+  imContext = aWindow->GetIMContext();
+  if (!IMEWasEnabled && imContext && imContext->IsEnabled()) {
+    // Notice our keydown event was already dispatched.  This prevents
+    // unnecessary DOM keydown event in the editor.
+    handlingState = imContext->OnKeyEvent(aWindow, aGdkKeyEvent, true);
+    if (handlingState == KeyHandlingState::eHandled) {
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), the event was handled by "
+               "IMContextWrapper which was enabled by the preceding eKeyDown "
+               "event"));
+      return;
+    }
+  }
+
+  // Look for specialized app-command keys
+  switch (aGdkKeyEvent->keyval) {
+    case GDK_Back:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Back);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Back\" command event"));
+      return;
+    case GDK_Forward:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Forward);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Forward\" command "
+               "event"));
+      return;
+    case GDK_Reload:
+    case GDK_Refresh:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Reload);
+      return;
+    case GDK_Stop:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Stop);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Stop\" command event"));
+      return;
+    case GDK_Search:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Search);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Search\" command event"));
+      return;
+    case GDK_Favorites:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Bookmarks);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Bookmarks\" command "
+               "event"));
+      return;
+    case GDK_HomePage:
+      aWindow->DispatchCommandEvent(nsGkAtoms::Home);
+      return;
+    case GDK_Copy:
+    case GDK_F16:  // F16, F20, F18, F14 are old keysyms for Copy Cut Paste Undo
+      aWindow->DispatchContentCommandEvent(eContentCommandCopy);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Copy\" content command "
+               "event"));
+      return;
+    case GDK_Cut:
+    case GDK_F20:
+      aWindow->DispatchContentCommandEvent(eContentCommandCut);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Cut\" content command "
+               "event"));
+      return;
+    case GDK_Paste:
+    case GDK_F18:
+      aWindow->DispatchContentCommandEvent(eContentCommandPaste);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Paste\" content command "
+               "event"));
+      return;
+    case GDK_Redo:
+      aWindow->DispatchContentCommandEvent(eContentCommandRedo);
+      return;
+    case GDK_Undo:
+    case GDK_F14:
+      aWindow->DispatchContentCommandEvent(eContentCommandUndo);
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched \"Undo\" content command "
+               "event"));
+      return;
+    default:
+      break;
+  }
+
+  // before we dispatch a key, check if it's the context menu key.
+  // If so, send a context menu key event instead.
+  if (MaybeDispatchContextMenuEvent(aWindow, aGdkKeyEvent)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("  HandleKeyPressEvent(), stopped dispatching eKeyPress event "
+             "because eContextMenu event was dispatched"));
+    return;
+  }
+
+  RefPtr<TextEventDispatcher> textEventDispatcher =
+      aWindow->GetTextEventDispatcher();
+  nsresult rv = textEventDispatcher->BeginNativeInputTransaction();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_LOG(gKeyLog, LogLevel::Error,
+            ("  HandleKeyPressEvent(), stopped dispatching eKeyPress event "
+             "because of failed to initialize TextEventDispatcher"));
+    return;
+  }
+
+  // If the character code is in the BMP, send the key press event.
+  // Otherwise, send a compositionchange event with the equivalent UTF-16
+  // string.
+  // TODO: Investigate other browser's behavior in this case because
+  //       this hack is odd for UI Events.
+  WidgetKeyboardEvent keypressEvent(true, eKeyPress, aWindow);
+  KeymapWrapper::InitKeyEvent(keypressEvent, aGdkKeyEvent, false);
+  nsEventStatus status = nsEventStatus_eIgnore;
+  if (keypressEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING ||
+      keypressEvent.mKeyValue.Length() == 1) {
+    if (textEventDispatcher->MaybeDispatchKeypressEvents(keypressEvent, status,
+                                                         aGdkKeyEvent)) {
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), dispatched eKeyPress event "
+               "(status=%s)",
+               GetStatusName(status)));
+    } else {
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyPressEvent(), didn't dispatch eKeyPress event "
+               "(status=%s)",
+               GetStatusName(status)));
+    }
+  } else {
+    WidgetEventTime eventTime = aWindow->GetWidgetEventTime(aGdkKeyEvent->time);
+    textEventDispatcher->CommitComposition(status, &keypressEvent.mKeyValue,
+                                           &eventTime);
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("  HandleKeyPressEvent(), dispatched a set of composition "
+             "events"));
+  }
+}
+
+/* static */
+bool KeymapWrapper::HandleKeyReleaseEvent(nsWindow* aWindow,
+                                          GdkEventKey* aGdkKeyEvent) {
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("HandleKeyReleaseEvent(aWindow=%p, aGdkKeyEvent={ type=%s, "
+           "keyval=%s(0x%X), state=0x%08X, hardware_keycode=0x%08X, "
+           "time=%u, is_modifier=%s })",
+           aWindow,
+           ((aGdkKeyEvent->type == GDK_KEY_PRESS) ? "GDK_KEY_PRESS"
+                                                  : "GDK_KEY_RELEASE"),
+           gdk_keyval_name(aGdkKeyEvent->keyval), aGdkKeyEvent->keyval,
+           aGdkKeyEvent->state, aGdkKeyEvent->hardware_keycode,
+           aGdkKeyEvent->time, GetBoolName(aGdkKeyEvent->is_modifier)));
+
+  RefPtr<IMContextWrapper> imContext = aWindow->GetIMContext();
+  if (imContext) {
+    KeyHandlingState handlingState =
+        imContext->OnKeyEvent(aWindow, aGdkKeyEvent);
+    if (handlingState != KeyHandlingState::eNotHandled) {
+      MOZ_LOG(gKeyLog, LogLevel::Info,
+              ("  HandleKeyReleaseEvent(), the event was handled by "
+               "IMContextWrapper"));
+      return true;
+    }
+  }
+
+  bool isCancelled = false;
+  if (NS_WARN_IF(!DispatchKeyDownOrKeyUpEvent(aWindow, aGdkKeyEvent, false,
+                                              &isCancelled))) {
+    MOZ_LOG(gKeyLog, LogLevel::Error,
+            ("  HandleKeyReleaseEvent(), didn't dispatch eKeyUp event"));
+    return false;
+  }
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("  HandleKeyReleaseEvent(), dispatched eKeyUp event "
+           "(isCancelled=%s)",
+           GetBoolName(isCancelled)));
+  return true;
+}
+
+/* static */
+void KeymapWrapper::InitKeyEvent(WidgetKeyboardEvent& aKeyEvent,
+                                 GdkEventKey* aGdkKeyEvent,
+                                 bool aIsProcessedByIME) {
+  MOZ_ASSERT(
+      !aIsProcessedByIME || aKeyEvent.mMessage != eKeyPress,
+      "If the key event is handled by IME, keypress event shouldn't be fired");
+
+  KeymapWrapper* keymapWrapper = GetInstance();
+
+  aKeyEvent.mCodeNameIndex = ComputeDOMCodeNameIndex(aGdkKeyEvent);
+  MOZ_ASSERT(aKeyEvent.mCodeNameIndex != CODE_NAME_INDEX_USE_STRING);
+  aKeyEvent.mKeyNameIndex =
+      aIsProcessedByIME ? KEY_NAME_INDEX_Process
+                        : keymapWrapper->ComputeDOMKeyNameIndex(aGdkKeyEvent);
+  if (aKeyEvent.mKeyNameIndex == KEY_NAME_INDEX_Unidentified) {
+    uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
+    if (!charCode) {
+      charCode = keymapWrapper->GetUnmodifiedCharCodeFor(aGdkKeyEvent);
+    }
+    if (charCode) {
+      aKeyEvent.mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
+      MOZ_ASSERT(aKeyEvent.mKeyValue.IsEmpty(),
+                 "Uninitialized mKeyValue must be empty");
+      AppendUCS4ToUTF16(charCode, aKeyEvent.mKeyValue);
+    }
+  }
+
+  if (aIsProcessedByIME) {
+    aKeyEvent.mKeyCode = NS_VK_PROCESSKEY;
+  } else if (aKeyEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING ||
+             aKeyEvent.mMessage != eKeyPress) {
+    aKeyEvent.mKeyCode = ComputeDOMKeyCode(aGdkKeyEvent);
+  } else {
+    aKeyEvent.mKeyCode = 0;
+  }
+
+  // NOTE: The state of given key event indicates adjacent state of
+  // modifier keys.  E.g., even if the event is Shift key press event,
+  // the bit for Shift is still false.  By the same token, even if the
+  // event is Shift key release event, the bit for Shift is still true.
+  // Unfortunately, gdk_keyboard_get_modifiers() returns current modifier
+  // state.  It means if there're some pending modifier key press or
+  // key release events, the result isn't what we want.
+  guint modifierState = aGdkKeyEvent->state;
+  GdkDisplay* gdkDisplay = gdk_display_get_default();
+#ifdef MOZ_X11
+  if (aGdkKeyEvent->is_modifier && GdkIsX11Display(gdkDisplay)) {
+    Display* display = gdk_x11_display_get_xdisplay(gdkDisplay);
+    if (XEventsQueued(display, QueuedAfterReading)) {
+      XEvent nextEvent;
+      XPeekEvent(display, &nextEvent);
+      if (nextEvent.type == keymapWrapper->mXKBBaseEventCode) {
+        XkbEvent* XKBEvent = (XkbEvent*)&nextEvent;
+        if (XKBEvent->any.xkb_type == XkbStateNotify) {
+          XkbStateNotifyEvent* stateNotifyEvent =
+              (XkbStateNotifyEvent*)XKBEvent;
+          modifierState &= ~0xFF;
+          modifierState |= stateNotifyEvent->lookup_mods;
+        }
+      }
+    }
+  }
+#endif
+  InitInputEvent(aKeyEvent, modifierState);
+
+  switch (aGdkKeyEvent->keyval) {
+    case GDK_Shift_L:
+    case GDK_Control_L:
+    case GDK_Alt_L:
+    case GDK_Super_L:
+    case GDK_Hyper_L:
+    case GDK_Meta_L:
+      aKeyEvent.mLocation = eKeyLocationLeft;
+      break;
+
+    case GDK_Shift_R:
+    case GDK_Control_R:
+    case GDK_Alt_R:
+    case GDK_Super_R:
+    case GDK_Hyper_R:
+    case GDK_Meta_R:
+      aKeyEvent.mLocation = eKeyLocationRight;
+      break;
+
+    case GDK_KP_0:
+    case GDK_KP_1:
+    case GDK_KP_2:
+    case GDK_KP_3:
+    case GDK_KP_4:
+    case GDK_KP_5:
+    case GDK_KP_6:
+    case GDK_KP_7:
+    case GDK_KP_8:
+    case GDK_KP_9:
+    case GDK_KP_Space:
+    case GDK_KP_Tab:
+    case GDK_KP_Enter:
+    case GDK_KP_F1:
+    case GDK_KP_F2:
+    case GDK_KP_F3:
+    case GDK_KP_F4:
+    case GDK_KP_Home:
+    case GDK_KP_Left:
+    case GDK_KP_Up:
+    case GDK_KP_Right:
+    case GDK_KP_Down:
+    case GDK_KP_Prior:  // same as GDK_KP_Page_Up
+    case GDK_KP_Next:   // same as GDK_KP_Page_Down
+    case GDK_KP_End:
+    case GDK_KP_Begin:
+    case GDK_KP_Insert:
+    case GDK_KP_Delete:
+    case GDK_KP_Equal:
+    case GDK_KP_Multiply:
+    case GDK_KP_Add:
+    case GDK_KP_Separator:
+    case GDK_KP_Subtract:
+    case GDK_KP_Decimal:
+    case GDK_KP_Divide:
+      aKeyEvent.mLocation = eKeyLocationNumpad;
+      break;
+
+    default:
+      aKeyEvent.mLocation = eKeyLocationStandard;
+      break;
+  }
+
+  // The transformations above and in gdk for the keyval are not invertible
+  // so link to the GdkEvent (which will vanish soon after return from the
+  // event callback) to give plugins access to hardware_keycode and state.
+  // (An XEvent would be nice but the GdkEvent is good enough.)
+  aKeyEvent.mNativeKeyEvent = static_cast<void*>(aGdkKeyEvent);
+  aKeyEvent.mIsRepeat =
+      sRepeatState == REPEATING &&
+      aGdkKeyEvent->hardware_keycode == sLastRepeatableHardwareKeyCode;
+
+  MOZ_LOG(
+      gKeyLog, LogLevel::Info,
+      ("%p InitKeyEvent, modifierState=0x%08X "
+       "aKeyEvent={ mMessage=%s, isShift=%s, isControl=%s, "
+       "isAlt=%s, isMeta=%s , mKeyCode=0x%02X, mCharCode=%s, "
+       "mKeyNameIndex=%s, mKeyValue=%s, mCodeNameIndex=%s, mCodeValue=%s, "
+       "mLocation=%s, mIsRepeat=%s }",
+       keymapWrapper, modifierState, ToChar(aKeyEvent.mMessage),
+       GetBoolName(aKeyEvent.IsShift()), GetBoolName(aKeyEvent.IsControl()),
+       GetBoolName(aKeyEvent.IsAlt()), GetBoolName(aKeyEvent.IsMeta()),
+       aKeyEvent.mKeyCode,
+       GetCharacterCodeName(static_cast<char16_t>(aKeyEvent.mCharCode)).get(),
+       ToString(aKeyEvent.mKeyNameIndex).get(),
+       GetCharacterCodeNames(aKeyEvent.mKeyValue).get(),
+       ToString(aKeyEvent.mCodeNameIndex).get(),
+       GetCharacterCodeNames(aKeyEvent.mCodeValue).get(),
+       GetKeyLocationName(aKeyEvent.mLocation).get(),
+       GetBoolName(aKeyEvent.mIsRepeat)));
+}
+
+/* static */
+uint32_t KeymapWrapper::GetCharCodeFor(const GdkEventKey* aGdkKeyEvent) {
+  // Anything above 0xf000 is considered a non-printable
+  // Exception: directly encoded UCS characters
+  if (aGdkKeyEvent->keyval > 0xf000 &&
+      (aGdkKeyEvent->keyval & 0xff000000) != 0x01000000) {
+    // Keypad keys are an exception: they return a value different
+    // from their non-keypad equivalents, but mozilla doesn't distinguish.
+    switch (aGdkKeyEvent->keyval) {
+      case GDK_KP_Space:
+        return ' ';
+      case GDK_KP_Equal:
+        return '=';
+      case GDK_KP_Multiply:
+        return '*';
+      case GDK_KP_Add:
+        return '+';
+      case GDK_KP_Separator:
+        return ',';
+      case GDK_KP_Subtract:
+        return '-';
+      case GDK_KP_Decimal:
+        return '.';
+      case GDK_KP_Divide:
+        return '/';
+      case GDK_KP_0:
+        return '0';
+      case GDK_KP_1:
+        return '1';
+      case GDK_KP_2:
+        return '2';
+      case GDK_KP_3:
+        return '3';
+      case GDK_KP_4:
+        return '4';
+      case GDK_KP_5:
+        return '5';
+      case GDK_KP_6:
+        return '6';
+      case GDK_KP_7:
+        return '7';
+      case GDK_KP_8:
+        return '8';
+      case GDK_KP_9:
+        return '9';
+      default:
+        return 0;  // non-printables
+    }
+  }
+
+  static const long MAX_UNICODE = 0x10FFFF;
+
+  // we're supposedly printable, let's try to convert
+  long ucs = keysym2ucs(aGdkKeyEvent->keyval);
+  if ((ucs != -1) && (ucs < MAX_UNICODE)) {
+    return ucs;
+  }
+
+  // I guess we couldn't convert
+  return 0;
+}
+
+uint32_t KeymapWrapper::GetCharCodeFor(const GdkEventKey* aGdkKeyEvent,
+                                       guint aModifierState, gint aGroup) {
+  guint keyval;
+  if (!gdk_keymap_translate_keyboard_state(
+          mGdkKeymap, aGdkKeyEvent->hardware_keycode,
+          GdkModifierType(aModifierState), aGroup, &keyval, nullptr, nullptr,
+          nullptr)) {
+    return 0;
+  }
+  GdkEventKey tmpEvent = *aGdkKeyEvent;
+  tmpEvent.state = aModifierState;
+  tmpEvent.keyval = keyval;
+  tmpEvent.group = aGroup;
+  return GetCharCodeFor(&tmpEvent);
+}
+
+uint32_t KeymapWrapper::GetUnmodifiedCharCodeFor(
+    const GdkEventKey* aGdkKeyEvent) {
+  guint state = aGdkKeyEvent->state &
+                (GetModifierMask(SHIFT) | GetModifierMask(CAPS_LOCK) |
+                 GetModifierMask(NUM_LOCK) | GetModifierMask(SCROLL_LOCK) |
+                 GetModifierMask(LEVEL3) | GetModifierMask(LEVEL5));
+  uint32_t charCode =
+      GetCharCodeFor(aGdkKeyEvent, GdkModifierType(state), aGdkKeyEvent->group);
+  if (charCode) {
+    return charCode;
+  }
+  // If no character is mapped to the key when Level3 Shift or Level5 Shift
+  // is active, let's return a character which is inputted by the key without
+  // Level3 nor Level5 Shift.
+  guint stateWithoutAltGraph =
+      state & ~(GetModifierMask(LEVEL3) | GetModifierMask(LEVEL5));
+  if (state == stateWithoutAltGraph) {
+    return 0;
+  }
+  return GetCharCodeFor(aGdkKeyEvent, GdkModifierType(stateWithoutAltGraph),
+                        aGdkKeyEvent->group);
+}
+
+gint KeymapWrapper::GetKeyLevel(GdkEventKey* aGdkKeyEvent) {
+  gint level;
+  if (!gdk_keymap_translate_keyboard_state(
+          mGdkKeymap, aGdkKeyEvent->hardware_keycode,
+          GdkModifierType(aGdkKeyEvent->state), aGdkKeyEvent->group, nullptr,
+          nullptr, &level, nullptr)) {
+    return -1;
+  }
+  return level;
+}
+
+gint KeymapWrapper::GetFirstLatinGroup() {
+  GdkKeymapKey* keys;
+  gint count;
+  gint minGroup = -1;
+  if (gdk_keymap_get_entries_for_keyval(mGdkKeymap, GDK_a, &keys, &count)) {
+    // find the minimum number group for latin inputtable layout
+    for (gint i = 0; i < count && minGroup != 0; ++i) {
+      if (keys[i].level != 0 && keys[i].level != 1) {
+        continue;
+      }
+      if (minGroup >= 0 && keys[i].group > minGroup) {
+        continue;
+      }
+      minGroup = keys[i].group;
+    }
+    g_free(keys);
+  }
+  return minGroup;
+}
+
+bool KeymapWrapper::IsLatinGroup(guint8 aGroup) {
+  GdkKeymapKey* keys;
+  gint count;
+  bool result = false;
+  if (gdk_keymap_get_entries_for_keyval(mGdkKeymap, GDK_a, &keys, &count)) {
+    for (gint i = 0; i < count; ++i) {
+      if (keys[i].level != 0 && keys[i].level != 1) {
+        continue;
+      }
+      if (keys[i].group == aGroup) {
+        result = true;
+        break;
+      }
+    }
+    g_free(keys);
+  }
+  return result;
+}
+
+bool KeymapWrapper::IsAutoRepeatableKey(guint aHardwareKeyCode) {
+#ifdef MOZ_X11
+  uint8_t indexOfArray = aHardwareKeyCode / 8;
+  MOZ_ASSERT(indexOfArray < ArrayLength(mKeyboardState.auto_repeats),
+             "invalid index");
+  char bitMask = 1 << (aHardwareKeyCode % 8);
+  return (mKeyboardState.auto_repeats[indexOfArray] & bitMask) != 0;
+#else
+  return false;
+#endif
+}
+
+/* static */
+bool KeymapWrapper::IsBasicLatinLetterOrNumeral(uint32_t aCharCode) {
+  return (aCharCode >= 'a' && aCharCode <= 'z') ||
+         (aCharCode >= 'A' && aCharCode <= 'Z') ||
+         (aCharCode >= '0' && aCharCode <= '9');
+}
+
+/* static */
+guint KeymapWrapper::GetGDKKeyvalWithoutModifier(
+    const GdkEventKey* aGdkKeyEvent) {
+  KeymapWrapper* keymapWrapper = GetInstance();
+  guint state =
+      (aGdkKeyEvent->state & keymapWrapper->GetModifierMask(NUM_LOCK));
+  guint keyval;
+  if (!gdk_keymap_translate_keyboard_state(
+          keymapWrapper->mGdkKeymap, aGdkKeyEvent->hardware_keycode,
+          GdkModifierType(state), aGdkKeyEvent->group, &keyval, nullptr,
+          nullptr, nullptr)) {
+    return 0;
+  }
+  return keyval;
+}
+
+/* static */
+uint32_t KeymapWrapper::GetDOMKeyCodeFromKeyPairs(guint aGdkKeyval) {
+  switch (aGdkKeyval) {
+    case GDK_Cancel:
+      return NS_VK_CANCEL;
+    case GDK_BackSpace:
+      return NS_VK_BACK;
+    case GDK_Tab:
+    case GDK_ISO_Left_Tab:
+      return NS_VK_TAB;
+    case GDK_Clear:
+      return NS_VK_CLEAR;
+    case GDK_Return:
+      return NS_VK_RETURN;
+    case GDK_Shift_L:
+    case GDK_Shift_R:
+    case GDK_Shift_Lock:
+      return NS_VK_SHIFT;
+    case GDK_Control_L:
+    case GDK_Control_R:
+      return NS_VK_CONTROL;
+    case GDK_Alt_L:
+    case GDK_Alt_R:
+      return NS_VK_ALT;
+    case GDK_Meta_L:
+    case GDK_Meta_R:
+      return NS_VK_META;
+
+    // Assume that Super or Hyper is always mapped to physical Win key.
+    case GDK_Super_L:
+    case GDK_Super_R:
+    case GDK_Hyper_L:
+    case GDK_Hyper_R:
+      return NS_VK_WIN;
+
+    // GTK's AltGraph key is similar to Mac's Option (Alt) key.  However,
+    // unfortunately, browsers on Mac are using NS_VK_ALT for it even though
+    // it's really different from Alt key on Windows.
+    // On the other hand, GTK's AltGrapsh keys are really different from
+    // Alt key.  However, there is no AltGrapsh key on Windows.  On Windows,
+    // both Ctrl and Alt keys are pressed internally when AltGr key is
+    // pressed.  For some languages' users, AltGraph key is important, so,
+    // web applications on such locale may want to know AltGraph key press.
+    // Therefore, we should map AltGr keycode for them only on GTK.
+    case GDK_ISO_Level3_Shift:
+    case GDK_ISO_Level5_Shift:
+    // We assume that Mode_switch is always used for level3 shift.
+    case GDK_Mode_switch:
+      return NS_VK_ALTGR;
+
+    case GDK_Pause:
+      return NS_VK_PAUSE;
+    case GDK_Caps_Lock:
+      return NS_VK_CAPS_LOCK;
+    case GDK_Kana_Lock:
+    case GDK_Kana_Shift:
+      return NS_VK_KANA;
+    case GDK_Hangul:
+      return NS_VK_HANGUL;
+    // case GDK_XXX:                   return NS_VK_JUNJA;
+    // case GDK_XXX:                   return NS_VK_FINAL;
+    case GDK_Hangul_Hanja:
+      return NS_VK_HANJA;
+    case GDK_Kanji:
+      return NS_VK_KANJI;
+    case GDK_Escape:
+      return NS_VK_ESCAPE;
+    case GDK_Henkan:
+      return NS_VK_CONVERT;
+    case GDK_Muhenkan:
+      return NS_VK_NONCONVERT;
+    // case GDK_XXX:                   return NS_VK_ACCEPT;
+    // case GDK_XXX:                   return NS_VK_MODECHANGE;
+    case GDK_Page_Up:
+      return NS_VK_PAGE_UP;
+    case GDK_Page_Down:
+      return NS_VK_PAGE_DOWN;
+    case GDK_End:
+      return NS_VK_END;
+    case GDK_Home:
+      return NS_VK_HOME;
+    case GDK_Left:
+      return NS_VK_LEFT;
+    case GDK_Up:
+      return NS_VK_UP;
+    case GDK_Right:
+      return NS_VK_RIGHT;
+    case GDK_Down:
+      return NS_VK_DOWN;
+    case GDK_Select:
+      return NS_VK_SELECT;
+    case GDK_Print:
+      return NS_VK_PRINT;
+    case GDK_Execute:
+      return NS_VK_EXECUTE;
+    case GDK_Insert:
+      return NS_VK_INSERT;
+    case GDK_Delete:
+      return NS_VK_DELETE;
+    case GDK_Help:
+      return NS_VK_HELP;
+
+    // keypad keys
+    case GDK_KP_Left:
+      return NS_VK_LEFT;
+    case GDK_KP_Right:
+      return NS_VK_RIGHT;
+    case GDK_KP_Up:
+      return NS_VK_UP;
+    case GDK_KP_Down:
+      return NS_VK_DOWN;
+    case GDK_KP_Page_Up:
+      return NS_VK_PAGE_UP;
+    // Not sure what these are
+    // case GDK_KP_Prior:              return NS_VK_;
+    // case GDK_KP_Next:               return NS_VK_;
+    case GDK_KP_Begin:
+      return NS_VK_CLEAR;  // Num-unlocked 5
+    case GDK_KP_Page_Down:
+      return NS_VK_PAGE_DOWN;
+    case GDK_KP_Home:
+      return NS_VK_HOME;
+    case GDK_KP_End:
+      return NS_VK_END;
+    case GDK_KP_Insert:
+      return NS_VK_INSERT;
+    case GDK_KP_Delete:
+      return NS_VK_DELETE;
+    case GDK_KP_Enter:
+      return NS_VK_RETURN;
+
+    case GDK_Num_Lock:
+      return NS_VK_NUM_LOCK;
+    case GDK_Scroll_Lock:
+      return NS_VK_SCROLL_LOCK;
+
+    // Function keys
+    case GDK_F1:
+      return NS_VK_F1;
+    case GDK_F2:
+      return NS_VK_F2;
+    case GDK_F3:
+      return NS_VK_F3;
+    case GDK_F4:
+      return NS_VK_F4;
+    case GDK_F5:
+      return NS_VK_F5;
+    case GDK_F6:
+      return NS_VK_F6;
+    case GDK_F7:
+      return NS_VK_F7;
+    case GDK_F8:
+      return NS_VK_F8;
+    case GDK_F9:
+      return NS_VK_F9;
+    case GDK_F10:
+      return NS_VK_F10;
+    case GDK_F11:
+      return NS_VK_F11;
+    case GDK_F12:
+      return NS_VK_F12;
+    case GDK_F13:
+      return NS_VK_F13;
+    case GDK_F14:
+      return NS_VK_F14;
+    case GDK_F15:
+      return NS_VK_F15;
+    case GDK_F16:
+      return NS_VK_F16;
+    case GDK_F17:
+      return NS_VK_F17;
+    case GDK_F18:
+      return NS_VK_F18;
+    case GDK_F19:
+      return NS_VK_F19;
+    case GDK_F20:
+      return NS_VK_F20;
+    case GDK_F21:
+      return NS_VK_F21;
+    case GDK_F22:
+      return NS_VK_F22;
+    case GDK_F23:
+      return NS_VK_F23;
+    case GDK_F24:
+      return NS_VK_F24;
+
+    // context menu key, keysym 0xff67, typically keycode 117 on 105-key
+    // (Microsoft) x86 keyboards, located between right 'Windows' key and
+    // right Ctrl key
+    case GDK_Menu:
+      return NS_VK_CONTEXT_MENU;
+    case GDK_Sleep:
+      return NS_VK_SLEEP;
+
+    case GDK_3270_Attn:
+      return NS_VK_ATTN;
+    case GDK_3270_CursorSelect:
+      return NS_VK_CRSEL;
+    case GDK_3270_ExSelect:
+      return NS_VK_EXSEL;
+    case GDK_3270_EraseEOF:
+      return NS_VK_EREOF;
+    case GDK_3270_Play:
+      return NS_VK_PLAY;
+    // case GDK_XXX:                   return NS_VK_ZOOM;
+    case GDK_3270_PA1:
+      return NS_VK_PA1;
+
+    // map Sun Keyboard special keysyms on to NS_VK keys
+
+    // Sun F11 key generates SunF36(0x1005ff10) keysym
+    case 0x1005ff10:
+      return NS_VK_F11;
+    // Sun F12 key generates SunF37(0x1005ff11) keysym
+    case 0x1005ff11:
+      return NS_VK_F12;
+    default:
+      return 0;
+  }
+}
+
+void KeymapWrapper::WillDispatchKeyboardEvent(WidgetKeyboardEvent& aKeyEvent,
+                                              GdkEventKey* aGdkKeyEvent) {
+  GetInstance()->WillDispatchKeyboardEventInternal(aKeyEvent, aGdkKeyEvent);
+}
+
+void KeymapWrapper::WillDispatchKeyboardEventInternal(
+    WidgetKeyboardEvent& aKeyEvent, GdkEventKey* aGdkKeyEvent) {
+  if (!aGdkKeyEvent) {
+    // If aGdkKeyEvent is nullptr, we're trying to dispatch a fake keyboard
+    // event in such case, we don't need to set alternative char codes.
+    // So, we don't need to do nothing here.  This case is typically we're
+    // dispatching eKeyDown or eKeyUp event during composition.
+    return;
+  }
+
+  uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
+  if (!charCode) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p WillDispatchKeyboardEventInternal, "
+             "mKeyCode=0x%02X, charCode=0x%08X",
+             this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode));
+    return;
+  }
+
+  // The mCharCode was set from mKeyValue. However, for example, when Ctrl key
+  // is pressed, its value should indicate an ASCII character for backward
+  // compatibility rather than inputting character without the modifiers.
+  // Therefore, we need to modify mCharCode value here.
+  aKeyEvent.SetCharCode(charCode);
+
+  gint level = GetKeyLevel(aGdkKeyEvent);
+  if (level != 0 && level != 1) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p WillDispatchKeyboardEventInternal, "
+             "mKeyCode=0x%02X, mCharCode=0x%08X, level=%d",
+             this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level));
+    return;
+  }
+
+  guint baseState =
+      aGdkKeyEvent->state & ~(GetModifierMask(SHIFT) | GetModifierMask(CTRL) |
+                              GetModifierMask(ALT) | GetModifierMask(META) |
+                              GetModifierMask(SUPER) | GetModifierMask(HYPER));
+
+  // We shold send both shifted char and unshifted char, all keyboard layout
+  // users can use all keys.  Don't change event.mCharCode. On some keyboard
+  // layouts, Ctrl/Alt/Meta keys are used for inputting some characters.
+  AlternativeCharCode altCharCodes(0, 0);
+  // unshifted charcode of current keyboard layout.
+  altCharCodes.mUnshiftedCharCode =
+      GetCharCodeFor(aGdkKeyEvent, baseState, aGdkKeyEvent->group);
+  bool isLatin = (altCharCodes.mUnshiftedCharCode <= 0xFF);
+  // shifted charcode of current keyboard layout.
+  altCharCodes.mShiftedCharCode = GetCharCodeFor(
+      aGdkKeyEvent, baseState | GetModifierMask(SHIFT), aGdkKeyEvent->group);
+  isLatin = isLatin && (altCharCodes.mShiftedCharCode <= 0xFF);
+  if (altCharCodes.mUnshiftedCharCode || altCharCodes.mShiftedCharCode) {
+    aKeyEvent.mAlternativeCharCodes.AppendElement(altCharCodes);
+  }
+
+  bool needLatinKeyCodes = !isLatin;
+  if (!needLatinKeyCodes) {
+    needLatinKeyCodes =
+        (IS_ASCII_ALPHABETICAL(altCharCodes.mUnshiftedCharCode) !=
+         IS_ASCII_ALPHABETICAL(altCharCodes.mShiftedCharCode));
+  }
+
+  // If current keyboard layout can input Latin characters, we don't need
+  // more information.
+  if (!needLatinKeyCodes) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p WillDispatchKeyboardEventInternal, "
+             "mKeyCode=0x%02X, mCharCode=0x%08X, level=%d, altCharCodes={ "
+             "mUnshiftedCharCode=0x%08X, mShiftedCharCode=0x%08X }",
+             this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level,
+             altCharCodes.mUnshiftedCharCode, altCharCodes.mShiftedCharCode));
+    return;
+  }
+
+  // Next, find Latin inputtable keyboard layout.
+  gint minGroup = GetFirstLatinGroup();
+  if (minGroup < 0) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("%p WillDispatchKeyboardEventInternal, "
+             "Latin keyboard layout isn't found: "
+             "mKeyCode=0x%02X, mCharCode=0x%08X, level=%d, "
+             "altCharCodes={ mUnshiftedCharCode=0x%08X, "
+             "mShiftedCharCode=0x%08X }",
+             this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level,
+             altCharCodes.mUnshiftedCharCode, altCharCodes.mShiftedCharCode));
+    return;
+  }
+
+  AlternativeCharCode altLatinCharCodes(0, 0);
+  uint32_t unmodifiedCh = aKeyEvent.IsShift() ? altCharCodes.mShiftedCharCode
+                                              : altCharCodes.mUnshiftedCharCode;
+
+  // unshifted charcode of found keyboard layout.
+  uint32_t ch = GetCharCodeFor(aGdkKeyEvent, baseState, minGroup);
+  altLatinCharCodes.mUnshiftedCharCode =
+      IsBasicLatinLetterOrNumeral(ch) ? ch : 0;
+  // shifted charcode of found keyboard layout.
+  ch = GetCharCodeFor(aGdkKeyEvent, baseState | GetModifierMask(SHIFT),
+                      minGroup);
+  altLatinCharCodes.mShiftedCharCode = IsBasicLatinLetterOrNumeral(ch) ? ch : 0;
+  if (altLatinCharCodes.mUnshiftedCharCode ||
+      altLatinCharCodes.mShiftedCharCode) {
+    aKeyEvent.mAlternativeCharCodes.AppendElement(altLatinCharCodes);
+  }
+  // If the mCharCode is not Latin, and the level is 0 or 1, we should
+  // replace the mCharCode to Latin char if Alt and Meta keys are not
+  // pressed. (Alt should be sent the localized char for accesskey
+  // like handling of Web Applications.)
+  ch = aKeyEvent.IsShift() ? altLatinCharCodes.mShiftedCharCode
+                           : altLatinCharCodes.mUnshiftedCharCode;
+  if (ch && !(aKeyEvent.IsAlt() || aKeyEvent.IsMeta()) &&
+      charCode == unmodifiedCh) {
+    aKeyEvent.SetCharCode(ch);
+  }
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("%p WillDispatchKeyboardEventInternal, "
+           "mKeyCode=0x%02X, mCharCode=0x%08X, level=%d, minGroup=%d, "
+           "altCharCodes={ mUnshiftedCharCode=0x%08X, "
+           "mShiftedCharCode=0x%08X } "
+           "altLatinCharCodes={ mUnshiftedCharCode=0x%08X, "
+           "mShiftedCharCode=0x%08X }",
+           this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level, minGroup,
+           altCharCodes.mUnshiftedCharCode, altCharCodes.mShiftedCharCode,
+           altLatinCharCodes.mUnshiftedCharCode,
+           altLatinCharCodes.mShiftedCharCode));
+}
+
+#ifdef MOZ_WAYLAND
+void KeymapWrapper::SetFocusIn(wl_surface* aFocusSurface,
+                               uint32_t aFocusSerial) {
+  LOGW("KeymapWrapper::SetFocusIn() surface %p ID %d serial %d", aFocusSurface,
+       aFocusSurface ? wl_proxy_get_id((struct wl_proxy*)aFocusSurface) : 0,
+       aFocusSerial);
+
+  KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
+  keymapWrapper->mFocusSurface = aFocusSurface;
+  keymapWrapper->mFocusSerial = aFocusSerial;
+}
+
+// aFocusSurface can be null in case that focused surface is already destroyed.
+void KeymapWrapper::SetFocusOut(wl_surface* aFocusSurface) {
+  KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
+  LOGW("KeymapWrapper::SetFocusOut surface %p ID %d", aFocusSurface,
+       aFocusSurface ? wl_proxy_get_id((struct wl_proxy*)aFocusSurface) : 0);
+
+  keymapWrapper->mFocusSurface = nullptr;
+  keymapWrapper->mFocusSerial = 0;
+}
+
+void KeymapWrapper::GetFocusInfo(wl_surface** aFocusSurface,
+                                 uint32_t* aFocusSerial) {
+  KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
+  *aFocusSurface = keymapWrapper->mFocusSurface;
+  *aFocusSerial = keymapWrapper->mFocusSerial;
+}
+
+void KeymapWrapper::SetSeat(wl_seat* aSeat) {
+  KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
+  keymapWrapper->mSeat = aSeat;
+}
+
+wl_seat* KeymapWrapper::GetSeat() {
+  KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
+  return keymapWrapper->mSeat;
+}
+#endif
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/nsGtkKeyUtils.h b/widget/gtk/nsGtkKeyUtils.h
new file mode 100644
index 0000000000..8462b6d03a
--- /dev/null
+++ b/widget/gtk/nsGtkKeyUtils.h
@@ -0,0 +1,508 @@
+/* -*- 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 __nsGdkKeyUtils_h__
+#define __nsGdkKeyUtils_h__
+
+#include "mozilla/EventForwards.h"
+#include "nsIWidget.h"
+#include "nsTArray.h"
+
+#include <gdk/gdk.h>
+#ifdef MOZ_X11
+#  include <X11/XKBlib.h>
+#endif
+#ifdef MOZ_WAYLAND
+#  include <gdk/gdkwayland.h>
+#  include <xkbcommon/xkbcommon.h>
+#endif
+#include "X11UndefineNone.h"
+
+class nsWindow;
+
+namespace mozilla {
+namespace widget {
+
+/**
+ *  KeymapWrapper is a wrapper class of GdkKeymap.  GdkKeymap doesn't support
+ *  all our needs, therefore, we need to access lower level APIs.
+ *  But such code is usually complex and might be slow.  Against such issues,
+ *  we should cache some information.
+ *
+ *  This class provides only static methods.  The methods is using internal
+ *  singleton instance which is initialized by default GdkKeymap.  When the
+ *  GdkKeymap is destroyed, the singleton instance will be destroyed.
+ */
+
+class KeymapWrapper {
+ public:
+  /**
+   * Compute an our DOM keycode from a GDK keyval.
+   */
+  static uint32_t ComputeDOMKeyCode(const GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * Compute a DOM key name index from aGdkKeyEvent.
+   */
+  static KeyNameIndex ComputeDOMKeyNameIndex(const GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * Compute a DOM code name index from aGdkKeyEvent.
+   */
+  static CodeNameIndex ComputeDOMCodeNameIndex(const GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * Modifier is list of modifiers which we support in widget level.
+   */
+  enum Modifier {
+    NOT_MODIFIER = 0x0000,
+    CAPS_LOCK = 0x0001,
+    NUM_LOCK = 0x0002,
+    SCROLL_LOCK = 0x0004,
+    SHIFT = 0x0008,
+    CTRL = 0x0010,
+    ALT = 0x0020,
+    META = 0x0040,
+    SUPER = 0x0080,
+    HYPER = 0x0100,
+    LEVEL3 = 0x0200,
+    LEVEL5 = 0x0400
+  };
+
+  /**
+   * Modifiers is used for combination of Modifier.
+   * E.g., |Modifiers modifiers = (SHIFT | CTRL);| means Shift and Ctrl.
+   */
+  typedef uint32_t Modifiers;
+
+  /**
+   * GetCurrentModifierState() returns current modifier key state.
+   * The "current" means actual state of hardware keyboard when this is
+   * called.  I.e., if some key events are not still dispatched by GDK,
+   * the state may mismatch with GdkEventKey::state.
+   *
+   * @return                  Current modifier key state.
+   */
+  static guint GetCurrentModifierState();
+
+  /**
+   * AreModifiersCurrentlyActive() checks the "current" modifier state
+   * on aGdkWindow with the keymap of the singleton instance.
+   *
+   * @param aModifiers        One or more of Modifier values except
+   *                          NOT_MODIFIER.
+   * @return                  TRUE if all of modifieres in aModifiers are
+   *                          active.  Otherwise, FALSE.
+   */
+  static bool AreModifiersCurrentlyActive(Modifiers aModifiers);
+
+  /**
+   * Utility function to compute current keyboard modifiers for
+   * WidgetInputEvent
+   */
+  static uint32_t ComputeCurrentKeyModifiers();
+
+  /**
+   * Utility function to covert platform modifier state to keyboard modifiers
+   * of WidgetInputEvent
+   */
+  static uint32_t ComputeKeyModifiers(guint aModifierState);
+
+  /**
+   * Convert native modifiers for `nsIWidget::SynthesizeNative*()` to
+   * GDK's state.
+   */
+  static guint ConvertWidgetModifierToGdkState(
+      nsIWidget::Modifiers aNativeModifiers);
+
+  /**
+   * InitInputEvent() initializes the aInputEvent with aModifierState.
+   */
+  static void InitInputEvent(WidgetInputEvent& aInputEvent,
+                             guint aModifierState);
+
+  /**
+   * InitKeyEvent() intializes aKeyEvent's modifier key related members
+   * and keycode related values.
+   *
+   * @param aKeyEvent         It's an WidgetKeyboardEvent which needs to be
+   *                          initialized.
+   * @param aGdkKeyEvent      A native GDK key event.
+   * @param aIsProcessedByIME true if aGdkKeyEvent is handled by IME.
+   */
+  static void InitKeyEvent(WidgetKeyboardEvent& aKeyEvent,
+                           GdkEventKey* aGdkKeyEvent, bool aIsProcessedByIME);
+
+  /**
+   * DispatchKeyDownOrKeyUpEvent() dispatches eKeyDown or eKeyUp event.
+   *
+   * @param aWindow           The window to dispatch a keyboard event.
+   * @param aGdkKeyEvent      A native GDK_KEY_PRESS or GDK_KEY_RELEASE
+   *                          event.
+   * @param aIsProcessedByIME true if the event is handled by IME.
+   * @param aIsCancelled      [Out] true if the default is prevented.
+   * @return                  true if eKeyDown event is actually dispatched.
+   *                          Otherwise, false.
+   */
+  static bool DispatchKeyDownOrKeyUpEvent(nsWindow* aWindow,
+                                          GdkEventKey* aGdkKeyEvent,
+                                          bool aIsProcessedByIME,
+                                          bool* aIsCancelled);
+
+  /**
+   * DispatchKeyDownOrKeyUpEvent() dispatches eKeyDown or eKeyUp event.
+   *
+   * @param aWindow           The window to dispatch aKeyboardEvent.
+   * @param aKeyboardEvent    An eKeyDown or eKeyUp event.  This will be
+   *                          dispatched as is.
+   * @param aIsCancelled      [Out] true if the default is prevented.
+   * @return                  true if eKeyDown event is actually dispatched.
+   *                          Otherwise, false.
+   */
+  static bool DispatchKeyDownOrKeyUpEvent(nsWindow* aWindow,
+                                          WidgetKeyboardEvent& aKeyboardEvent,
+                                          bool* aIsCancelled);
+
+  /**
+   * GDK_KEY_PRESS event handler.
+   *
+   * @param aWindow           The window to dispatch eKeyDown event (and maybe
+   *                          eKeyPress events).
+   * @param aGdkKeyEvent      Receivied GDK_KEY_PRESS event.
+   */
+  static void HandleKeyPressEvent(nsWindow* aWindow, GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * GDK_KEY_RELEASE event handler.
+   *
+   * @param aWindow           The window to dispatch eKeyUp event.
+   * @param aGdkKeyEvent      Receivied GDK_KEY_RELEASE event.
+   * @return                  true if an event is dispatched.  Otherwise, false.
+   */
+  static bool HandleKeyReleaseEvent(nsWindow* aWindow,
+                                    GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * WillDispatchKeyboardEvent() is called via
+   * TextEventDispatcherListener::WillDispatchKeyboardEvent().
+   *
+   * @param aKeyEvent         An instance of KeyboardEvent which will be
+   *                          dispatched.  This method should set charCode
+   *                          and alternative char codes if it's necessary.
+   * @param aGdkKeyEvent      A GdkEventKey instance which caused the
+   *                          aKeyEvent.
+   */
+  static void WillDispatchKeyboardEvent(WidgetKeyboardEvent& aKeyEvent,
+                                        GdkEventKey* aGdkKeyEvent);
+
+#ifdef MOZ_WAYLAND
+  /**
+   * Utility function to set all supported modifier masks
+   * from xkb_keymap. We call that from Wayland backend routines.
+   */
+  static void SetModifierMasks(xkb_keymap* aKeymap);
+
+  /**
+   * Wayland global focus handlers
+   */
+  static void SetFocusIn(wl_surface* aFocusSurface, uint32_t aFocusSerial);
+  static void SetFocusOut(wl_surface* aFocusSurface);
+  static void GetFocusInfo(wl_surface** aFocusSurface, uint32_t* aFocusSerial);
+
+  static void SetSeat(wl_seat* aSeat);
+  static wl_seat* GetSeat();
+
+  /**
+   * EnsureInstance() is provided on Wayland to register Wayland callbacks
+   * early.
+   */
+  static void EnsureInstance();
+#endif
+
+  /**
+   * ResetKeyboard is called on keymap changes from OnKeysChanged and
+   * keyboard_handle_keymap to prepare for keymap changes.
+   */
+  static void ResetKeyboard();
+
+  /**
+   * Destroys the singleton KeymapWrapper instance, if it exists.
+   */
+  static void Shutdown();
+
+ protected:
+  /**
+   * GetInstance() returns a KeymapWrapper instance.
+   *
+   * @return                  A singleton instance of KeymapWrapper.
+   */
+  static KeymapWrapper* GetInstance();
+
+  KeymapWrapper();
+  ~KeymapWrapper();
+
+  bool mInitialized;
+
+  /**
+   * Initializing methods.
+   */
+  void Init();
+#ifdef MOZ_X11
+  void InitXKBExtension();
+  void InitBySystemSettingsX11();
+#endif
+#ifdef MOZ_WAYLAND
+  void InitBySystemSettingsWayland();
+#endif
+
+  /**
+   * mModifierKeys stores each hardware key information.
+   */
+  struct ModifierKey {
+    guint mHardwareKeycode;
+    guint mMask;
+
+    explicit ModifierKey(guint aHardwareKeycode)
+        : mHardwareKeycode(aHardwareKeycode), mMask(0) {}
+  };
+  nsTArray<ModifierKey> mModifierKeys;
+
+  /**
+   * GetModifierKey() returns modifier key information of the hardware
+   * keycode.  If the key isn't a modifier key, returns nullptr.
+   */
+  ModifierKey* GetModifierKey(guint aHardwareKeycode);
+
+  /**
+   * mModifierMasks is bit masks for each modifier.  The index should be one
+   * of ModifierIndex values.
+   */
+  enum ModifierIndex {
+    INDEX_NUM_LOCK,
+    INDEX_SCROLL_LOCK,
+    INDEX_ALT,
+    INDEX_META,
+    INDEX_SUPER,
+    INDEX_HYPER,
+    INDEX_LEVEL3,
+    INDEX_LEVEL5,
+    COUNT_OF_MODIFIER_INDEX
+  };
+  guint mModifierMasks[COUNT_OF_MODIFIER_INDEX];
+
+  guint GetModifierMask(Modifier aModifier) const;
+
+  /**
+   * @param aGdkKeyval        A GDK defined modifier key value such as
+   *                          GDK_Shift_L.
+   * @return                  Returns Modifier values for aGdkKeyval.
+   *                          If the given key code isn't a modifier key,
+   *                          returns NOT_MODIFIER.
+   */
+  static Modifier GetModifierForGDKKeyval(guint aGdkKeyval);
+
+  static const char* GetModifierName(Modifier aModifier);
+
+  /**
+   * AreModifiersActive() just checks whether aModifierState indicates
+   * all modifiers in aModifiers are active or not.
+   *
+   * @param aModifiers        One or more of Modifier values except
+   *                          NOT_MODIFIER.
+   * @param aModifierState    GDK's modifier states.
+   * @return                  TRUE if aGdkModifierType indecates all of
+   *                          modifiers in aModifier are active.
+   *                          Otherwise, FALSE.
+   */
+  static bool AreModifiersActive(Modifiers aModifiers, guint aModifierState);
+
+  /**
+   * mGdkKeymap is a wrapped instance by this class.
+   */
+  GdkKeymap* mGdkKeymap;
+
+  /**
+   * The base event code of XKB extension.
+   */
+  int mXKBBaseEventCode;
+
+#ifdef MOZ_X11
+  /**
+   * Only auto_repeats[] stores valid value.  If you need to use other
+   * members, you need to listen notification events for them.
+   * See a call of XkbSelectEventDetails() with XkbControlsNotify in
+   * InitXKBExtension().
+   */
+  XKeyboardState mKeyboardState;
+#endif
+
+  /**
+   * Pointer of the singleton instance.
+   */
+  static KeymapWrapper* sInstance;
+
+  /**
+   * Auto key repeat management.
+   */
+  static guint sLastRepeatableHardwareKeyCode;
+#ifdef MOZ_X11
+  static Time sLastRepeatableKeyTime;
+#endif
+  enum RepeatState { NOT_PRESSED, FIRST_PRESS, REPEATING };
+  static RepeatState sRepeatState;
+
+  /**
+   * IsAutoRepeatableKey() returns true if the key supports auto repeat.
+   * Otherwise, false.
+   */
+  bool IsAutoRepeatableKey(guint aHardwareKeyCode);
+
+  /**
+   * Signal handlers.
+   */
+  static void OnKeysChanged(GdkKeymap* aKeymap, KeymapWrapper* aKeymapWrapper);
+  static void OnDirectionChanged(GdkKeymap* aGdkKeymap,
+                                 KeymapWrapper* aKeymapWrapper);
+
+  gulong mOnKeysChangedSignalHandle;
+  gulong mOnDirectionChangedSignalHandle;
+
+  /**
+   * GetCharCodeFor() Computes what character is inputted by the key event
+   * with aModifierState and aGroup.
+   *
+   * @param aGdkKeyEvent      Native key event, must not be nullptr.
+   * @param aModifierState    Combination of GdkModifierType which you
+   *                          want to test with aGdkKeyEvent.
+   * @param aGroup            Set group in the mGdkKeymap.
+   * @return                  charCode which is inputted by aGdkKeyEvent.
+   *                          If failed, this returns 0.
+   */
+  static uint32_t GetCharCodeFor(const GdkEventKey* aGdkKeyEvent);
+  uint32_t GetCharCodeFor(const GdkEventKey* aGdkKeyEvent, guint aModifierState,
+                          gint aGroup);
+
+  /**
+   * GetUnmodifiedCharCodeFor() computes what character is inputted by the
+   * key event without Ctrl/Alt/Meta/Super/Hyper modifiers.
+   * If Level3 or Level5 Shift causes no character input, this also ignores
+   * them.
+   *
+   * @param aGdkKeyEvent      Native key event, must not be nullptr.
+   * @return                  charCode which is computed without modifiers
+   *                          which prevent text input.
+   */
+  uint32_t GetUnmodifiedCharCodeFor(const GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * GetKeyLevel() returns level of the aGdkKeyEvent in mGdkKeymap.
+   *
+   * @param aGdkKeyEvent      Native key event, must not be nullptr.
+   * @return                  Using level.  Typically, this is 0 or 1.
+   *                          If failed, this returns -1.
+   */
+  gint GetKeyLevel(GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * GetFirstLatinGroup() returns group of mGdkKeymap which can input an
+   * ASCII character by GDK_A.
+   *
+   * @return                  group value of GdkEventKey.
+   */
+  gint GetFirstLatinGroup();
+
+  /**
+   * IsLatinGroup() checkes whether the keyboard layout of aGroup is
+   * ASCII alphabet inputtable or not.
+   *
+   * @param aGroup            The group value of GdkEventKey.
+   * @return                  TRUE if the keyboard layout can input
+   *                          ASCII alphabet.  Otherwise, FALSE.
+   */
+  bool IsLatinGroup(guint8 aGroup);
+
+  /**
+   * IsBasicLatinLetterOrNumeral() Checks whether the aCharCode is an
+   * alphabet or a numeric character in ASCII.
+   *
+   * @param aCharCode         Charcode which you want to test.
+   * @return                  TRUE if aCharCode is an alphabet or a numeric
+   *                          in ASCII range.  Otherwise, FALSE.
+   */
+  static bool IsBasicLatinLetterOrNumeral(uint32_t aCharCode);
+
+  /**
+   * IsPrintableASCIICharacter() checks whether the aCharCode is a printable
+   * ASCII character.  I.e., returns false if aCharCode is a control
+   * character even in an ASCII character.
+   */
+  static bool IsPrintableASCIICharacter(uint32_t aCharCode) {
+    return aCharCode >= 0x20 && aCharCode <= 0x7E;
+  }
+
+  /**
+   * GetGDKKeyvalWithoutModifier() returns the keyval for aGdkKeyEvent when
+   * ignoring the modifier state except NumLock. (NumLock is a key to change
+   * some key's meaning.)
+   */
+  static guint GetGDKKeyvalWithoutModifier(const GdkEventKey* aGdkKeyEvent);
+
+  /**
+   * GetDOMKeyCodeFromKeyPairs() returns DOM keycode for aGdkKeyval if
+   * it's in KeyPair table.
+   */
+  static uint32_t GetDOMKeyCodeFromKeyPairs(guint aGdkKeyval);
+
+#ifdef MOZ_X11
+  /**
+   * FilterEvents() listens all events on all our windows.
+   * Be careful, this may make damage to performance if you add expensive
+   * code in this method.
+   */
+  static GdkFilterReturn FilterEvents(GdkXEvent* aXEvent, GdkEvent* aGdkEvent,
+                                      gpointer aData);
+#endif
+
+  /**
+   * MaybeDispatchContextMenuEvent() may dispatch eContextMenu event if
+   * the given key combination should cause opening context menu.
+   *
+   * @param aWindow           The window to dispatch a contextmenu event.
+   * @param aEvent            The native key event.
+   * @return                  true if this method dispatched eContextMenu
+   *                          event.  Otherwise, false.
+   *                          Be aware, when this returns true, the
+   *                          widget may have been destroyed.
+   */
+  static bool MaybeDispatchContextMenuEvent(nsWindow* aWindow,
+                                            const GdkEventKey* aEvent);
+
+  /**
+   * See the document of WillDispatchKeyboardEvent().
+   */
+  void WillDispatchKeyboardEventInternal(WidgetKeyboardEvent& aKeyEvent,
+                                         GdkEventKey* aGdkKeyEvent);
+
+#ifdef MOZ_WAYLAND
+  /**
+   * Utility function to set Xkb modifier key mask.
+   */
+  void SetModifierMask(xkb_keymap* aKeymap, ModifierIndex aModifierIndex,
+                       const char* aModifierName);
+#endif
+
+#ifdef MOZ_WAYLAND
+  wl_seat* mSeat = nullptr;
+  wl_surface* mFocusSurface = nullptr;
+  uint32_t mFocusSerial = 0;
+#endif
+};
+
+}  // namespace widget
+}  // namespace mozilla
+
+#endif /* __nsGdkKeyUtils_h__ */
diff --git a/widget/gtk/nsGtkUtils.h b/widget/gtk/nsGtkUtils.h
new file mode 100644
index 0000000000..ae26049e7f
--- /dev/null
+++ b/widget/gtk/nsGtkUtils.h
@@ -0,0 +1,59 @@
+/* -*- 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 nsGtkUtils_h__
+#define nsGtkUtils_h__
+
+#include <glib.h>
+
+// Some gobject functions expect functions for gpointer arguments.
+// gpointer is void* but C++ doesn't like casting functions to void*.
+template <class T>
+static inline gpointer FuncToGpointer(T aFunction) {
+  return reinterpret_cast<gpointer>(
+      reinterpret_cast<uintptr_t>
+      // This cast just provides a warning if T is not a function.
+      (reinterpret_cast<void (*)()>(aFunction)));
+}
+
+// Type-safe alternative to glib's g_clear_pointer.
+//
+// Using `g_clear_pointer` itself causes UBSan to report undefined
+// behavior. The function-based definition of `g_clear_pointer` (as
+// opposed to the older preprocessor macro) treats the `destroy`
+// function as a `void (*)(void *)`, but the actual destroy functions
+// that are used (say `wl_buffer_destroy`) usually have more specific
+// pointer types.
+//
+// C++ draft n4901 [expr.call] para 6:
+//
+//     Calling a function through an expression whose function type E
+//     is different from the function type F of the called function’s
+//     definition results in undefined behavior unless the type
+//     “pointer to F” can be converted to the type “pointer to E” via
+//     a function pointer conversion (7.3.14).
+//
+// §7.3.14 only talks about converting between noexcept and ordinary
+// function pointers.
+template <class T>
+static inline void MozClearPointer(T*& pointer, void (*destroy)(T*)) {
+  T* hold = pointer;
+  pointer = nullptr;
+  if (hold) {
+    destroy(hold);
+  }
+}
+
+template <class T>
+static inline void MozClearHandleID(T& handle, gboolean (*destroy)(T)) {
+  if (handle) {
+    destroy(handle);
+    handle = 0;
+  }
+}
+
+#endif  // nsGtkUtils_h__
diff --git a/widget/gtk/nsImageToPixbuf.cpp b/widget/gtk/nsImageToPixbuf.cpp
new file mode 100644
index 0000000000..73094b74ef
--- /dev/null
+++ b/widget/gtk/nsImageToPixbuf.cpp
@@ -0,0 +1,121 @@
+/* vim:set sw=2 sts=2 et cin: */
+/* 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 <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "nsImageToPixbuf.h"
+
+#include "imgIContainer.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/RefPtr.h"
+#include "GRefPtr.h"
+#include "nsCOMPtr.h"
+
+using mozilla::gfx::DataSourceSurface;
+using mozilla::gfx::SurfaceFormat;
+
+inline unsigned char unpremultiply(unsigned char color, unsigned char alpha) {
+  if (alpha == 0) return 0;
+  // plus alpha/2 to round instead of truncate
+  return (color * 255 + alpha / 2) / alpha;
+}
+
+already_AddRefed<GdkPixbuf> nsImageToPixbuf::ImageToPixbuf(
+    imgIContainer* aImage, const mozilla::Maybe<nsIntSize>& aOverrideSize) {
+  RefPtr<SourceSurface> surface;
+
+  const uint32_t flags =
+      imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY;
+  if (aOverrideSize) {
+    surface = aImage->GetFrameAtSize(*aOverrideSize,
+                                     imgIContainer::FRAME_CURRENT, flags);
+  } else {
+    surface = aImage->GetFrame(imgIContainer::FRAME_CURRENT, flags);
+  }
+
+  // If the last call failed, it was probably because our call stack originates
+  // in an imgINotificationObserver event, meaning that we're not allowed
+  // request a sync decode. Presumably the originating event is something
+  // sensible like OnStopFrame(), so we can just retry the call without a sync
+  // decode.
+  if (!surface) {
+    if (aOverrideSize) {
+      surface =
+          aImage->GetFrameAtSize(*aOverrideSize, imgIContainer::FRAME_CURRENT,
+                                 imgIContainer::FLAG_NONE);
+    } else {
+      surface = aImage->GetFrame(imgIContainer::FRAME_CURRENT,
+                                 imgIContainer::FLAG_NONE);
+    }
+  }
+
+  NS_ENSURE_TRUE(surface, nullptr);
+
+  return SourceSurfaceToPixbuf(surface, surface->GetSize().width,
+                               surface->GetSize().height);
+}
+
+already_AddRefed<GdkPixbuf> nsImageToPixbuf::SourceSurfaceToPixbuf(
+    SourceSurface* aSurface, int32_t aWidth, int32_t aHeight) {
+  MOZ_ASSERT(aWidth <= aSurface->GetSize().width &&
+                 aHeight <= aSurface->GetSize().height,
+             "Requested rect is bigger than the supplied surface");
+
+  RefPtr<GdkPixbuf> pixbuf =
+      dont_AddRef(gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, aWidth, aHeight));
+  if (!pixbuf) {
+    return nullptr;
+  }
+
+  uint32_t destStride = gdk_pixbuf_get_rowstride(pixbuf);
+  guchar* destPixels = gdk_pixbuf_get_pixels(pixbuf);
+
+  RefPtr<DataSourceSurface> dataSurface = aSurface->GetDataSurface();
+  DataSourceSurface::MappedSurface map;
+  if (!dataSurface->Map(DataSourceSurface::MapType::READ, &map)) {
+    return nullptr;
+  }
+
+  uint8_t* srcData = map.mData;
+  int32_t srcStride = map.mStride;
+
+  SurfaceFormat format = dataSurface->GetFormat();
+
+  for (int32_t row = 0; row < aHeight; ++row) {
+    for (int32_t col = 0; col < aWidth; ++col) {
+      guchar* destPixel = destPixels + row * destStride + 4 * col;
+
+      uint32_t* srcPixel =
+          reinterpret_cast<uint32_t*>((srcData + row * srcStride + 4 * col));
+
+      if (format == SurfaceFormat::B8G8R8A8) {
+        const uint8_t a = (*srcPixel >> 24) & 0xFF;
+        const uint8_t r = unpremultiply((*srcPixel >> 16) & 0xFF, a);
+        const uint8_t g = unpremultiply((*srcPixel >> 8) & 0xFF, a);
+        const uint8_t b = unpremultiply((*srcPixel >> 0) & 0xFF, a);
+
+        *destPixel++ = r;
+        *destPixel++ = g;
+        *destPixel++ = b;
+        *destPixel++ = a;
+      } else {
+        MOZ_ASSERT(format == SurfaceFormat::B8G8R8X8);
+
+        const uint8_t r = (*srcPixel >> 16) & 0xFF;
+        const uint8_t g = (*srcPixel >> 8) & 0xFF;
+        const uint8_t b = (*srcPixel >> 0) & 0xFF;
+
+        *destPixel++ = r;
+        *destPixel++ = g;
+        *destPixel++ = b;
+        *destPixel++ = 0xFF;  // A
+      }
+    }
+  }
+
+  dataSurface->Unmap();
+
+  return pixbuf.forget();
+}
diff --git a/widget/gtk/nsImageToPixbuf.h b/widget/gtk/nsImageToPixbuf.h
new file mode 100644
index 0000000000..500489d7eb
--- /dev/null
+++ b/widget/gtk/nsImageToPixbuf.h
@@ -0,0 +1,37 @@
+/* vim:set sw=2 sts=2 et cin: */
+/* 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 NSIMAGETOPIXBUF_H_
+#define NSIMAGETOPIXBUF_H_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "nsSize.h"
+
+class imgIContainer;
+typedef struct _GdkPixbuf GdkPixbuf;
+
+namespace mozilla::gfx {
+class SourceSurface;
+}  // namespace mozilla::gfx
+
+class nsImageToPixbuf final {
+  using SourceSurface = mozilla::gfx::SourceSurface;
+
+ public:
+  // Friendlier version of ConvertImageToPixbuf for callers inside of
+  // widget
+  static already_AddRefed<GdkPixbuf> ImageToPixbuf(
+      imgIContainer* aImage,
+      const mozilla::Maybe<nsIntSize>& aOverrideSize = mozilla::Nothing());
+  static already_AddRefed<GdkPixbuf> SourceSurfaceToPixbuf(
+      SourceSurface* aSurface, int32_t aWidth, int32_t aHeight);
+
+ private:
+  ~nsImageToPixbuf() = default;
+};
+
+#endif
diff --git a/widget/gtk/nsLookAndFeel.cpp b/widget/gtk/nsLookAndFeel.cpp
new file mode 100644
index 0000000000..b1a89511a1
--- /dev/null
+++ b/widget/gtk/nsLookAndFeel.cpp
@@ -0,0 +1,2161 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// for strtod()
+#include <stdlib.h>
+#include <dlfcn.h>
+
+#include "nsLookAndFeel.h"
+
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+
+#include <pango/pango.h>
+#include <pango/pango-fontmap.h>
+#include <fontconfig/fontconfig.h>
+
+#include "GRefPtr.h"
+#include "GUniquePtr.h"
+#include "nsGtkUtils.h"
+#include "gfxPlatformGtk.h"
+#include "mozilla/FontPropertyTypes.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/RelativeLuminanceUtils.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/WidgetUtilsGtk.h"
+#include "ScreenHelperGTK.h"
+#include "ScrollbarDrawing.h"
+
+#include "gtkdrawing.h"
+#include "nsString.h"
+#include "nsStyleConsts.h"
+#include "gfxFontConstants.h"
+#include "WidgetUtils.h"
+#include "nsWindow.h"
+
+#include "mozilla/gfx/2D.h"
+
+#include <cairo-gobject.h>
+#include <dlfcn.h>
+#include "WidgetStyleCache.h"
+#include "prenv.h"
+#include "nsCSSColorUtils.h"
+#include "mozilla/Preferences.h"
+
+using namespace mozilla;
+using namespace mozilla::widget;
+
+#ifdef MOZ_LOGGING
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+static LazyLogModule gLnfLog("LookAndFeel");
+#  define LOGLNF(...) MOZ_LOG(gLnfLog, LogLevel::Debug, (__VA_ARGS__))
+#  define LOGLNF_ENABLED() MOZ_LOG_TEST(gLnfLog, LogLevel::Debug)
+#else
+#  define LOGLNF(args)
+#  define LOGLNF_ENABLED() false
+#endif /* MOZ_LOGGING */
+
+#define GDK_COLOR_TO_NS_RGB(c) \
+  ((nscolor)NS_RGB(c.red >> 8, c.green >> 8, c.blue >> 8))
+#define GDK_RGBA_TO_NS_RGBA(c)                                    \
+  ((nscolor)NS_RGBA((int)((c).red * 255), (int)((c).green * 255), \
+                    (int)((c).blue * 255), (int)((c).alpha * 255)))
+
+static bool sIgnoreChangedSettings = false;
+
+static void OnSettingsChange() {
+  if (sIgnoreChangedSettings) {
+    return;
+  }
+  // TODO: We could be more granular here, but for now assume everything
+  // changed.
+  LookAndFeel::NotifyChangedAllWindows(widget::ThemeChangeKind::StyleAndLayout);
+  widget::IMContextWrapper::OnThemeChanged();
+}
+
+static void settings_changed_cb(GtkSettings*, GParamSpec*, void*) {
+  OnSettingsChange();
+}
+
+static bool sCSDAvailable;
+
+static nsCString GVariantToString(GVariant* aVariant) {
+  nsCString ret;
+  gchar* s = g_variant_print(aVariant, TRUE);
+  if (s) {
+    ret.Assign(s);
+    g_free(s);
+  }
+  return ret;
+}
+
+static nsDependentCString GVariantGetString(GVariant* aVariant) {
+  gsize len = 0;
+  const gchar* v = g_variant_get_string(aVariant, &len);
+  return nsDependentCString(v, len);
+}
+
+// Observed settings for portal.
+static constexpr struct {
+  nsLiteralCString mNamespace;
+  nsLiteralCString mKey;
+} kObservedSettings[] = {
+    {"org.freedesktop.appearance"_ns, "color-scheme"_ns},
+};
+
+static void settings_changed_signal_cb(GDBusProxy* proxy, gchar* sender_name,
+                                       gchar* signal_name, GVariant* parameters,
+                                       gpointer user_data) {
+  LOGLNF("Settings Change sender=%s signal=%s params=%s\n", sender_name,
+         signal_name, GVariantToString(parameters).get());
+  if (strcmp(signal_name, "SettingChanged")) {
+    NS_WARNING("Unknown change signal for settings");
+    return;
+  }
+  RefPtr<GVariant> ns = dont_AddRef(g_variant_get_child_value(parameters, 0));
+  RefPtr<GVariant> key = dont_AddRef(g_variant_get_child_value(parameters, 1));
+  // Third parameter is the value, but we don't care about it.
+  if (!ns || !key || !g_variant_is_of_type(ns, G_VARIANT_TYPE_STRING) ||
+      !g_variant_is_of_type(key, G_VARIANT_TYPE_STRING)) {
+    MOZ_ASSERT(false, "Unexpected setting change signal parameters");
+    return;
+  }
+
+  auto nsStr = GVariantGetString(ns);
+  auto keyStr = GVariantGetString(key);
+  for (const auto& setting : kObservedSettings) {
+    if (setting.mNamespace.Equals(nsStr) && setting.mKey.Equals(keyStr)) {
+      OnSettingsChange();
+      return;
+    }
+  }
+}
+
+nsLookAndFeel::nsLookAndFeel() {
+  static constexpr nsLiteralCString kObservedSettings[] = {
+      // Affects system font sizes.
+      "notify::gtk-xft-dpi"_ns,
+      // Affects mSystemTheme and mAltTheme as expected.
+      "notify::gtk-theme-name"_ns,
+      // System fonts?
+      "notify::gtk-font-name"_ns,
+      // prefers-reduced-motion
+      "notify::gtk-enable-animations"_ns,
+      // CSD media queries, etc.
+      "notify::gtk-decoration-layout"_ns,
+      // Text resolution affects system font and widget sizes.
+      "notify::resolution"_ns,
+      // These three Affect mCaretBlinkTime
+      "notify::gtk-cursor-blink"_ns,
+      "notify::gtk-cursor-blink-time"_ns,
+      "notify::gtk-cursor-blink-timeout"_ns,
+      // Affects SelectTextfieldsOnKeyFocus
+      "notify::gtk-entry-select-on-focus"_ns,
+      // Affects ScrollToClick
+      "notify::gtk-primary-button-warps-slider"_ns,
+      // Affects SubmenuDelay
+      "notify::gtk-menu-popup-delay"_ns,
+      // Affects DragThresholdX/Y
+      "notify::gtk-dnd-drag-threshold"_ns,
+  };
+
+  GtkSettings* settings = gtk_settings_get_default();
+  for (const auto& setting : kObservedSettings) {
+    g_signal_connect_after(settings, setting.get(),
+                           G_CALLBACK(settings_changed_cb), nullptr);
+  }
+
+  sCSDAvailable =
+      nsWindow::GetSystemGtkWindowDecoration() != nsWindow::GTK_DECORATION_NONE;
+
+  if (ShouldUsePortal(PortalKind::Settings)) {
+    GUniquePtr<GError> error;
+    mDBusSettingsProxy = dont_AddRef(g_dbus_proxy_new_for_bus_sync(
+        G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, nullptr,
+        "org.freedesktop.portal.Desktop", "/org/freedesktop/portal/desktop",
+        "org.freedesktop.portal.Settings", nullptr, getter_Transfers(error)));
+    if (mDBusSettingsProxy) {
+      g_signal_connect(mDBusSettingsProxy, "g-signal",
+                       G_CALLBACK(settings_changed_signal_cb), nullptr);
+    } else {
+      LOGLNF("Can't create DBus proxy for settings: %s\n", error->message);
+    }
+  }
+}
+
+nsLookAndFeel::~nsLookAndFeel() {
+  if (mDBusSettingsProxy) {
+    g_signal_handlers_disconnect_by_func(
+        mDBusSettingsProxy, FuncToGpointer(settings_changed_signal_cb),
+        nullptr);
+    mDBusSettingsProxy = nullptr;
+  }
+  g_signal_handlers_disconnect_by_func(
+      gtk_settings_get_default(), FuncToGpointer(settings_changed_cb), nullptr);
+}
+
+#if 0
+static void DumpStyleContext(GtkStyleContext* aStyle) {
+  static auto sGtkStyleContextToString =
+      reinterpret_cast<char* (*)(GtkStyleContext*, gint)>(
+          dlsym(RTLD_DEFAULT, "gtk_style_context_to_string"));
+  char* str = sGtkStyleContextToString(aStyle, ~0);
+  printf("%s\n", str);
+  g_free(str);
+  str = gtk_widget_path_to_string(gtk_style_context_get_path(aStyle));
+  printf("%s\n", str);
+  g_free(str);
+}
+#endif
+
+// Modifies color |*aDest| as if a pattern of color |aSource| was painted with
+// CAIRO_OPERATOR_OVER to a surface with color |*aDest|.
+static void ApplyColorOver(const GdkRGBA& aSource, GdkRGBA* aDest) {
+  gdouble sourceCoef = aSource.alpha;
+  gdouble destCoef = aDest->alpha * (1.0 - sourceCoef);
+  gdouble resultAlpha = sourceCoef + destCoef;
+  if (resultAlpha != 0.0) {  // don't divide by zero
+    destCoef /= resultAlpha;
+    sourceCoef /= resultAlpha;
+    aDest->red = sourceCoef * aSource.red + destCoef * aDest->red;
+    aDest->green = sourceCoef * aSource.green + destCoef * aDest->green;
+    aDest->blue = sourceCoef * aSource.blue + destCoef * aDest->blue;
+    aDest->alpha = resultAlpha;
+  }
+}
+
+static void GetLightAndDarkness(const GdkRGBA& aColor, double* aLightness,
+                                double* aDarkness) {
+  double sum = aColor.red + aColor.green + aColor.blue;
+  *aLightness = sum * aColor.alpha;
+  *aDarkness = (3.0 - sum) * aColor.alpha;
+}
+
+static bool GetGradientColors(const GValue* aValue, GdkRGBA* aLightColor,
+                              GdkRGBA* aDarkColor) {
+  if (!G_TYPE_CHECK_VALUE_TYPE(aValue, CAIRO_GOBJECT_TYPE_PATTERN)) {
+    return false;
+  }
+
+  auto pattern = static_cast<cairo_pattern_t*>(g_value_get_boxed(aValue));
+  if (!pattern) {
+    return false;
+  }
+
+  // Just picking the lightest and darkest colors as simple samples rather
+  // than trying to blend, which could get messy if there are many stops.
+  if (CAIRO_STATUS_SUCCESS !=
+      cairo_pattern_get_color_stop_rgba(pattern, 0, nullptr, &aDarkColor->red,
+                                        &aDarkColor->green, &aDarkColor->blue,
+                                        &aDarkColor->alpha)) {
+    return false;
+  }
+
+  double maxLightness, maxDarkness;
+  GetLightAndDarkness(*aDarkColor, &maxLightness, &maxDarkness);
+  *aLightColor = *aDarkColor;
+
+  GdkRGBA stop;
+  for (int index = 1;
+       CAIRO_STATUS_SUCCESS ==
+       cairo_pattern_get_color_stop_rgba(pattern, index, nullptr, &stop.red,
+                                         &stop.green, &stop.blue, &stop.alpha);
+       ++index) {
+    double lightness, darkness;
+    GetLightAndDarkness(stop, &lightness, &darkness);
+    if (lightness > maxLightness) {
+      maxLightness = lightness;
+      *aLightColor = stop;
+    }
+    if (darkness > maxDarkness) {
+      maxDarkness = darkness;
+      *aDarkColor = stop;
+    }
+  }
+
+  return true;
+}
+
+static bool GetColorFromImagePattern(const GValue* aValue, nscolor* aColor) {
+  if (!G_TYPE_CHECK_VALUE_TYPE(aValue, CAIRO_GOBJECT_TYPE_PATTERN)) {
+    return false;
+  }
+
+  auto pattern = static_cast<cairo_pattern_t*>(g_value_get_boxed(aValue));
+  if (!pattern) {
+    return false;
+  }
+
+  cairo_surface_t* surface;
+  if (cairo_pattern_get_surface(pattern, &surface) != CAIRO_STATUS_SUCCESS) {
+    return false;
+  }
+
+  cairo_format_t format = cairo_image_surface_get_format(surface);
+  if (format == CAIRO_FORMAT_INVALID) {
+    return false;
+  }
+  int width = cairo_image_surface_get_width(surface);
+  int height = cairo_image_surface_get_height(surface);
+  int stride = cairo_image_surface_get_stride(surface);
+  if (!width || !height) {
+    return false;
+  }
+
+  // Guesstimate the central pixel would have a sensible color.
+  int x = width / 2;
+  int y = height / 2;
+
+  unsigned char* data = cairo_image_surface_get_data(surface);
+  switch (format) {
+    // Most (all?) GTK images / patterns / etc use ARGB32.
+    case CAIRO_FORMAT_ARGB32: {
+      size_t offset = x * 4 + y * stride;
+      uint32_t* pixel = reinterpret_cast<uint32_t*>(data + offset);
+      *aColor = gfx::sRGBColor::UnusualFromARGB(*pixel).ToABGR();
+      return true;
+    }
+    default:
+      break;
+  }
+
+  return false;
+}
+
+static bool GetUnicoBorderGradientColors(GtkStyleContext* aContext,
+                                         GdkRGBA* aLightColor,
+                                         GdkRGBA* aDarkColor) {
+  // Ubuntu 12.04 has GTK engine Unico-1.0.2, which overrides render_frame,
+  // providing its own border code.  Ubuntu 14.04 has
+  // Unico-1.0.3+14.04.20140109, which does not override render_frame, and
+  // so does not need special attention.  The earlier Unico can be detected
+  // by the -unico-border-gradient style property it registers.
+  // gtk_style_properties_lookup_property() is checked first to avoid the
+  // warning from gtk_style_context_get_property() when the property does
+  // not exist.  (gtk_render_frame() of GTK+ 3.16 no longer uses the
+  // engine.)
+  const char* propertyName = "-unico-border-gradient";
+  if (!gtk_style_properties_lookup_property(propertyName, nullptr, nullptr))
+    return false;
+
+  // -unico-border-gradient is used only when the CSS node's engine is Unico.
+  GtkThemingEngine* engine;
+  GtkStateFlags state = gtk_style_context_get_state(aContext);
+  gtk_style_context_get(aContext, state, "engine", &engine, nullptr);
+  if (strcmp(g_type_name(G_TYPE_FROM_INSTANCE(engine)), "UnicoEngine") != 0)
+    return false;
+
+  // draw_border() of Unico engine uses -unico-border-gradient
+  // in preference to border-color.
+  GValue value = G_VALUE_INIT;
+  gtk_style_context_get_property(aContext, propertyName, state, &value);
+
+  bool result = GetGradientColors(&value, aLightColor, aDarkColor);
+
+  g_value_unset(&value);
+  return result;
+}
+
+// Sets |aLightColor| and |aDarkColor| to colors from |aContext|.  Returns
+// true if |aContext| uses these colors to render a visible border.
+// If returning false, then the colors returned are a fallback from the
+// border-color value even though |aContext| does not use these colors to
+// render a border.
+static bool GetBorderColors(GtkStyleContext* aContext, GdkRGBA* aLightColor,
+                            GdkRGBA* aDarkColor) {
+  // Determine whether the border on this style context is visible.
+  GtkStateFlags state = gtk_style_context_get_state(aContext);
+  GtkBorderStyle borderStyle;
+  gtk_style_context_get(aContext, state, GTK_STYLE_PROPERTY_BORDER_STYLE,
+                        &borderStyle, nullptr);
+  bool visible = borderStyle != GTK_BORDER_STYLE_NONE &&
+                 borderStyle != GTK_BORDER_STYLE_HIDDEN;
+  if (visible) {
+    // GTK has an initial value of zero for border-widths, and so themes
+    // need to explicitly set border-widths to make borders visible.
+    GtkBorder border;
+    gtk_style_context_get_border(aContext, state, &border);
+    visible = border.top != 0 || border.right != 0 || border.bottom != 0 ||
+              border.left != 0;
+  }
+
+  if (visible &&
+      GetUnicoBorderGradientColors(aContext, aLightColor, aDarkColor))
+    return true;
+
+  // The initial value for the border-color is the foreground color, and so
+  // this will usually return a color distinct from the background even if
+  // there is no visible border detected.
+  gtk_style_context_get_border_color(aContext, state, aDarkColor);
+  // TODO GTK3 - update aLightColor
+  // for GTK_BORDER_STYLE_INSET/OUTSET/GROVE/RIDGE border styles.
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=978172#c25
+  *aLightColor = *aDarkColor;
+  return visible;
+}
+
+static bool GetBorderColors(GtkStyleContext* aContext, nscolor* aLightColor,
+                            nscolor* aDarkColor) {
+  GdkRGBA lightColor, darkColor;
+  bool ret = GetBorderColors(aContext, &lightColor, &darkColor);
+  *aLightColor = GDK_RGBA_TO_NS_RGBA(lightColor);
+  *aDarkColor = GDK_RGBA_TO_NS_RGBA(darkColor);
+  return ret;
+}
+
+// Finds ideal cell highlight colors used for unfocused+selected cells distinct
+// from both Highlight, used as focused+selected background, and the listbox
+// background which is assumed to be similar to -moz-field
+void nsLookAndFeel::PerThemeData::InitCellHighlightColors() {
+  int32_t minLuminosityDifference = NS_SUFFICIENT_LUMINOSITY_DIFFERENCE_BG;
+  int32_t backLuminosityDifference =
+      NS_LUMINOSITY_DIFFERENCE(mMozWindowBackground, mFieldBackground);
+  if (backLuminosityDifference >= minLuminosityDifference) {
+    mMozCellHighlightBackground = mMozWindowBackground;
+    mMozCellHighlightText = mMozWindowText;
+    return;
+  }
+
+  uint16_t hue, sat, luminance;
+  uint8_t alpha;
+  mMozCellHighlightBackground = mFieldBackground;
+  mMozCellHighlightText = mFieldText;
+
+  NS_RGB2HSV(mMozCellHighlightBackground, hue, sat, luminance, alpha);
+
+  uint16_t step = 30;
+  // Lighten the color if the color is very dark
+  if (luminance <= step) {
+    luminance += step;
+  }
+  // Darken it if it is very light
+  else if (luminance >= 255 - step) {
+    luminance -= step;
+  }
+  // Otherwise, compute what works best depending on the text luminance.
+  else {
+    uint16_t textHue, textSat, textLuminance;
+    uint8_t textAlpha;
+    NS_RGB2HSV(mMozCellHighlightText, textHue, textSat, textLuminance,
+               textAlpha);
+    // Text is darker than background, use a lighter shade
+    if (textLuminance < luminance) {
+      luminance += step;
+    }
+    // Otherwise, use a darker shade
+    else {
+      luminance -= step;
+    }
+  }
+  NS_HSV2RGB(mMozCellHighlightBackground, hue, sat, luminance, alpha);
+}
+
+void nsLookAndFeel::NativeInit() { EnsureInit(); }
+
+void nsLookAndFeel::RefreshImpl() {
+  mInitialized = false;
+  moz_gtk_refresh();
+
+  nsXPLookAndFeel::RefreshImpl();
+}
+
+nsresult nsLookAndFeel::NativeGetColor(ColorID aID, ColorScheme aScheme,
+                                       nscolor& aColor) {
+  EnsureInit();
+
+  auto& theme = aScheme == ColorScheme::Light ? LightTheme() : DarkTheme();
+  return theme.GetColor(aID, aColor);
+}
+
+static bool ShouldUseColorForActiveDarkScrollbarThumb(nscolor aColor) {
+  auto IsDifferentEnough = [](int32_t aChannel, int32_t aOtherChannel) {
+    return std::abs(aChannel - aOtherChannel) > 10;
+  };
+  return IsDifferentEnough(NS_GET_R(aColor), NS_GET_G(aColor)) ||
+         IsDifferentEnough(NS_GET_R(aColor), NS_GET_B(aColor));
+}
+
+static bool ShouldUseThemedScrollbarColor(StyleSystemColor aID, nscolor aColor,
+                                          bool aIsDark) {
+  if (!aIsDark) {
+    return true;
+  }
+  if (StaticPrefs::widget_non_native_theme_scrollbar_dark_themed()) {
+    return true;
+  }
+  return aID == StyleSystemColor::ThemedScrollbarThumbActive &&
+         StaticPrefs::widget_non_native_theme_scrollbar_active_always_themed();
+}
+
+nsresult nsLookAndFeel::PerThemeData::GetColor(ColorID aID,
+                                               nscolor& aColor) const {
+  nsresult res = NS_OK;
+
+  switch (aID) {
+      // These colors don't seem to be used for anything anymore in Mozilla
+      // The CSS2 colors below are used.
+    case ColorID::Appworkspace:  // MDI background color
+    case ColorID::Background:    // desktop background
+    case ColorID::Window:
+    case ColorID::Windowframe:
+    case ColorID::MozDialog:
+    case ColorID::MozCombobox:
+      aColor = mMozWindowBackground;
+      break;
+    case ColorID::Windowtext:
+    case ColorID::MozDialogtext:
+      aColor = mMozWindowText;
+      break;
+    case ColorID::IMESelectedRawTextBackground:
+    case ColorID::IMESelectedConvertedTextBackground:
+    case ColorID::MozDragtargetzone:
+    case ColorID::Highlight:  // preference selected item,
+      aColor = mTextSelectedBackground;
+      break;
+    case ColorID::Highlighttext:
+      if (NS_GET_A(mTextSelectedBackground) < 155) {
+        aColor = NS_SAME_AS_FOREGROUND_COLOR;
+        break;
+      }
+      [[fallthrough]];
+    case ColorID::IMESelectedRawTextForeground:
+    case ColorID::IMESelectedConvertedTextForeground:
+      aColor = mTextSelectedText;
+      break;
+    case ColorID::Selecteditem:
+      aColor = mSelectedItem;
+      break;
+    case ColorID::Selecteditemtext:
+      aColor = mSelectedItemText;
+      break;
+    case ColorID::Accentcolor:
+      aColor = mAccentColor;
+      break;
+    case ColorID::Accentcolortext:
+      aColor = mAccentColorText;
+      break;
+    case ColorID::MozCellhighlight:
+      aColor = mMozCellHighlightBackground;
+      break;
+    case ColorID::MozCellhighlighttext:
+      aColor = mMozCellHighlightText;
+      break;
+    case ColorID::IMERawInputBackground:
+    case ColorID::IMEConvertedTextBackground:
+      aColor = NS_TRANSPARENT;
+      break;
+    case ColorID::IMERawInputForeground:
+    case ColorID::IMEConvertedTextForeground:
+      aColor = NS_SAME_AS_FOREGROUND_COLOR;
+      break;
+    case ColorID::IMERawInputUnderline:
+    case ColorID::IMEConvertedTextUnderline:
+      aColor = NS_SAME_AS_FOREGROUND_COLOR;
+      break;
+    case ColorID::IMESelectedRawTextUnderline:
+    case ColorID::IMESelectedConvertedTextUnderline:
+      aColor = NS_TRANSPARENT;
+      break;
+    case ColorID::Scrollbar:
+      aColor = mThemedScrollbar;
+      break;
+    case ColorID::ThemedScrollbar:
+      aColor = mThemedScrollbar;
+      if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) {
+        return NS_ERROR_FAILURE;
+      }
+      break;
+    case ColorID::ThemedScrollbarInactive:
+      aColor = mThemedScrollbarInactive;
+      if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) {
+        return NS_ERROR_FAILURE;
+      }
+      break;
+    case ColorID::ThemedScrollbarThumb:
+      aColor = mThemedScrollbarThumb;
+      if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) {
+        return NS_ERROR_FAILURE;
+      }
+      break;
+    case ColorID::ThemedScrollbarThumbHover:
+      aColor = mThemedScrollbarThumbHover;
+      if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) {
+        return NS_ERROR_FAILURE;
+      }
+      break;
+    case ColorID::ThemedScrollbarThumbActive:
+      aColor = mThemedScrollbarThumbActive;
+      if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) {
+        return NS_ERROR_FAILURE;
+      }
+      break;
+    case ColorID::ThemedScrollbarThumbInactive:
+      aColor = mThemedScrollbarThumbInactive;
+      if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) {
+        return NS_ERROR_FAILURE;
+      }
+      break;
+
+      // css2  http://www.w3.org/TR/REC-CSS2/ui.html#system-colors
+    case ColorID::Activeborder:
+      // active window border
+      aColor = mMozWindowActiveBorder;
+      break;
+    case ColorID::Inactiveborder:
+      // inactive window border
+      aColor = mMozWindowInactiveBorder;
+      break;
+    case ColorID::Graytext:  // disabled text in windows, menus, etc.
+      aColor = mMenuTextInactive;
+      break;
+    case ColorID::Activecaption:
+      aColor = mTitlebarBackground;
+      break;
+    case ColorID::Captiontext:  // text in active window caption (titlebar)
+      aColor = mTitlebarText;
+      break;
+    case ColorID::Inactivecaption:
+      // inactive window caption
+      aColor = mTitlebarInactiveBackground;
+      break;
+    case ColorID::Inactivecaptiontext:  // text in active window caption
+                                        // (titlebar)
+      aColor = mTitlebarInactiveText;
+      break;
+    case ColorID::Infobackground:
+      // tooltip background color
+      aColor = mInfoBackground;
+      break;
+    case ColorID::Infotext:
+      // tooltip text color
+      aColor = mInfoText;
+      break;
+    case ColorID::Menu:
+      // menu background
+      aColor = mMenuBackground;
+      break;
+    case ColorID::Menutext:
+      // menu text
+      aColor = mMenuText;
+      break;
+    case ColorID::Threedface:
+    case ColorID::Buttonface:
+    case ColorID::MozButtondisabledface:
+      // 3-D face color
+      aColor = mMozWindowBackground;
+      break;
+
+    case ColorID::Buttontext:
+      // text on push buttons
+      aColor = mButtonText;
+      break;
+
+    case ColorID::Buttonhighlight:
+      // 3-D highlighted edge color
+    case ColorID::Threedhighlight:
+      // 3-D highlighted outer edge color
+      aColor = mFrameOuterLightBorder;
+      break;
+
+    case ColorID::Buttonshadow:
+      // 3-D shadow edge color
+    case ColorID::Threedshadow:
+      // 3-D shadow inner edge color
+      aColor = mFrameInnerDarkBorder;
+      break;
+
+    case ColorID::Threedlightshadow:
+    case ColorID::Buttonborder:
+    case ColorID::MozDisabledfield:
+      aColor = mIsDark ? *GenericDarkColor(aID) : NS_RGB(0xE0, 0xE0, 0xE0);
+      break;
+    case ColorID::Threeddarkshadow:
+      aColor = mIsDark ? *GenericDarkColor(aID) : NS_RGB(0xDC, 0xDC, 0xDC);
+      break;
+
+    case ColorID::MozEventreerow:
+    case ColorID::Field:
+      aColor = mFieldBackground;
+      break;
+    case ColorID::Fieldtext:
+      aColor = mFieldText;
+      break;
+    case ColorID::MozButtondefault:
+      // default button border color
+      aColor = mButtonDefault;
+      break;
+    case ColorID::MozButtonhoverface:
+    case ColorID::MozButtonactiveface:
+      aColor = mButtonHoverFace;
+      break;
+    case ColorID::MozButtonhovertext:
+      aColor = mButtonHoverText;
+      break;
+    case ColorID::MozButtonactivetext:
+      aColor = mButtonActiveText;
+      break;
+    case ColorID::MozMenuhover:
+      aColor = mMenuHover;
+      break;
+    case ColorID::MozMenuhoverdisabled:
+      aColor = NS_TRANSPARENT;
+      break;
+    case ColorID::MozMenuhovertext:
+      aColor = mMenuHoverText;
+      break;
+    case ColorID::MozOddtreerow:
+      aColor = mOddCellBackground;
+      break;
+    case ColorID::MozNativehyperlinktext:
+      aColor = mNativeHyperLinkText;
+      break;
+    case ColorID::MozNativevisitedhyperlinktext:
+      aColor = mNativeVisitedHyperLinkText;
+      break;
+    case ColorID::MozComboboxtext:
+      aColor = mComboBoxText;
+      break;
+    case ColorID::MozMenubartext:
+      aColor = mMenuBarText;
+      break;
+    case ColorID::MozMenubarhovertext:
+      aColor = mMenuBarHoverText;
+      break;
+    case ColorID::MozColheadertext:
+      aColor = mMozColHeaderText;
+      break;
+    case ColorID::MozColheaderhovertext:
+      aColor = mMozColHeaderHoverText;
+      break;
+    case ColorID::SpellCheckerUnderline:
+    case ColorID::Mark:
+    case ColorID::Marktext:
+      aColor = GetStandinForNativeColor(
+          aID, mIsDark ? ColorScheme::Dark : ColorScheme::Light);
+      break;
+    default:
+      /* default color is BLACK */
+      aColor = 0;
+      res = NS_ERROR_FAILURE;
+      break;
+  }
+
+  return res;
+}
+
+static int32_t CheckWidgetStyle(GtkWidget* aWidget, const char* aStyle,
+                                int32_t aResult) {
+  gboolean value = FALSE;
+  gtk_widget_style_get(aWidget, aStyle, &value, nullptr);
+  return value ? aResult : 0;
+}
+
+static int32_t ConvertGTKStepperStyleToMozillaScrollArrowStyle(
+    GtkWidget* aWidget) {
+  if (!aWidget) return mozilla::LookAndFeel::eScrollArrowStyle_Single;
+
+  return CheckWidgetStyle(aWidget, "has-backward-stepper",
+                          mozilla::LookAndFeel::eScrollArrow_StartBackward) |
+         CheckWidgetStyle(aWidget, "has-forward-stepper",
+                          mozilla::LookAndFeel::eScrollArrow_EndForward) |
+         CheckWidgetStyle(aWidget, "has-secondary-backward-stepper",
+                          mozilla::LookAndFeel::eScrollArrow_EndBackward) |
+         CheckWidgetStyle(aWidget, "has-secondary-forward-stepper",
+                          mozilla::LookAndFeel::eScrollArrow_StartForward);
+}
+
+nsresult nsLookAndFeel::NativeGetInt(IntID aID, int32_t& aResult) {
+  nsresult res = NS_OK;
+
+  // We use delayed initialization by EnsureInit() here
+  // to make sure mozilla::Preferences is available (Bug 115807).
+  // IntID::UseAccessibilityTheme is requested before user preferences
+  // are read, and so EnsureInit(), which depends on preference values,
+  // is deliberately delayed until required.
+  switch (aID) {
+    case IntID::ScrollButtonLeftMouseButtonAction:
+      aResult = 0;
+      break;
+    case IntID::ScrollButtonMiddleMouseButtonAction:
+      aResult = 1;
+      break;
+    case IntID::ScrollButtonRightMouseButtonAction:
+      aResult = 2;
+      break;
+    case IntID::CaretBlinkTime:
+      EnsureInit();
+      aResult = mCaretBlinkTime;
+      break;
+    case IntID::CaretBlinkCount:
+      EnsureInit();
+      aResult = mCaretBlinkCount;
+      break;
+    case IntID::CaretWidth:
+      aResult = 1;
+      break;
+    case IntID::ShowCaretDuringSelection:
+      aResult = 0;
+      break;
+    case IntID::SelectTextfieldsOnKeyFocus: {
+      GtkSettings* settings;
+      gboolean select_on_focus;
+
+      settings = gtk_settings_get_default();
+      g_object_get(settings, "gtk-entry-select-on-focus", &select_on_focus,
+                   nullptr);
+
+      if (select_on_focus)
+        aResult = 1;
+      else
+        aResult = 0;
+
+    } break;
+    case IntID::ScrollToClick: {
+      GtkSettings* settings;
+      gboolean warps_slider = FALSE;
+
+      settings = gtk_settings_get_default();
+      if (g_object_class_find_property(G_OBJECT_GET_CLASS(settings),
+                                       "gtk-primary-button-warps-slider")) {
+        g_object_get(settings, "gtk-primary-button-warps-slider", &warps_slider,
+                     nullptr);
+      }
+
+      if (warps_slider)
+        aResult = 1;
+      else
+        aResult = 0;
+    } break;
+    case IntID::SubmenuDelay: {
+      GtkSettings* settings;
+      gint delay;
+
+      settings = gtk_settings_get_default();
+      g_object_get(settings, "gtk-menu-popup-delay", &delay, nullptr);
+      aResult = (int32_t)delay;
+      break;
+    }
+    case IntID::TooltipDelay: {
+      aResult = 500;
+      break;
+    }
+    case IntID::MenusCanOverlapOSBar:
+      // we want XUL popups to be able to overlap the task bar.
+      aResult = 1;
+      break;
+    case IntID::SkipNavigatingDisabledMenuItem:
+      aResult = 1;
+      break;
+    case IntID::DragThresholdX:
+    case IntID::DragThresholdY: {
+      gint threshold = 0;
+      g_object_get(gtk_settings_get_default(), "gtk-dnd-drag-threshold",
+                   &threshold, nullptr);
+
+      aResult = threshold;
+    } break;
+    case IntID::ScrollArrowStyle: {
+      GtkWidget* scrollbar = GetWidget(MOZ_GTK_SCROLLBAR_VERTICAL);
+      aResult = ConvertGTKStepperStyleToMozillaScrollArrowStyle(scrollbar);
+      break;
+    }
+    case IntID::TreeOpenDelay:
+      aResult = 1000;
+      break;
+    case IntID::TreeCloseDelay:
+      aResult = 1000;
+      break;
+    case IntID::TreeLazyScrollDelay:
+      aResult = 150;
+      break;
+    case IntID::TreeScrollDelay:
+      aResult = 100;
+      break;
+    case IntID::TreeScrollLinesMax:
+      aResult = 3;
+      break;
+    case IntID::AlertNotificationOrigin:
+      aResult = NS_ALERT_TOP;
+      break;
+    case IntID::IMERawInputUnderlineStyle:
+    case IntID::IMEConvertedTextUnderlineStyle:
+      aResult = static_cast<int32_t>(StyleTextDecorationStyle::Solid);
+      break;
+    case IntID::IMESelectedRawTextUnderlineStyle:
+    case IntID::IMESelectedConvertedTextUnderline:
+      aResult = static_cast<int32_t>(StyleTextDecorationStyle::None);
+      break;
+    case IntID::SpellCheckerUnderlineStyle:
+      aResult = static_cast<int32_t>(StyleTextDecorationStyle::Wavy);
+      break;
+    case IntID::MenuBarDrag:
+      EnsureInit();
+      aResult = mSystemTheme.mMenuSupportsDrag;
+      break;
+    case IntID::ScrollbarButtonAutoRepeatBehavior:
+      aResult = 1;
+      break;
+    case IntID::SwipeAnimationEnabled:
+      aResult = 1;
+      break;
+    case IntID::ContextMenuOffsetVertical:
+    case IntID::ContextMenuOffsetHorizontal:
+      aResult = 2;
+      break;
+    case IntID::GTKCSDAvailable:
+      aResult = sCSDAvailable;
+      break;
+    case IntID::GTKCSDMaximizeButton:
+      EnsureInit();
+      aResult = mCSDMaximizeButton;
+      break;
+    case IntID::GTKCSDMinimizeButton:
+      EnsureInit();
+      aResult = mCSDMinimizeButton;
+      break;
+    case IntID::GTKCSDCloseButton:
+      EnsureInit();
+      aResult = mCSDCloseButton;
+      break;
+    case IntID::GTKCSDReversedPlacement:
+      EnsureInit();
+      aResult = mCSDReversedPlacement;
+      break;
+    case IntID::PrefersReducedMotion: {
+      aResult = mPrefersReducedMotion;
+      break;
+    }
+    case IntID::SystemUsesDarkTheme: {
+      EnsureInit();
+      if (mColorSchemePreference) {
+        aResult = *mColorSchemePreference == ColorScheme::Dark;
+      } else {
+        aResult = mSystemTheme.mIsDark;
+      }
+      break;
+    }
+    case IntID::GTKCSDMaximizeButtonPosition:
+      aResult = mCSDMaximizeButtonPosition;
+      break;
+    case IntID::GTKCSDMinimizeButtonPosition:
+      aResult = mCSDMinimizeButtonPosition;
+      break;
+    case IntID::GTKCSDCloseButtonPosition:
+      aResult = mCSDCloseButtonPosition;
+      break;
+    case IntID::UseAccessibilityTheme: {
+      EnsureInit();
+      aResult = mSystemTheme.mHighContrast;
+      break;
+    }
+    case IntID::TitlebarRadius: {
+      EnsureInit();
+      aResult = EffectiveTheme().mTitlebarRadius;
+      break;
+    }
+    case IntID::GtkMenuRadius: {
+      EnsureInit();
+      aResult = EffectiveTheme().mMenuRadius;
+      break;
+    }
+    case IntID::AllowOverlayScrollbarsOverlap: {
+      aResult = 1;
+      break;
+    }
+    case IntID::ScrollbarFadeBeginDelay: {
+      aResult = 1000;
+      break;
+    }
+    case IntID::ScrollbarFadeDuration: {
+      aResult = 400;
+      break;
+    }
+    case IntID::ScrollbarDisplayOnMouseMove: {
+      aResult = 1;
+      break;
+    }
+    case IntID::PanelAnimations:
+      aResult = [&]() -> bool {
+        if (!sCSDAvailable) {
+          // Disabled on systems without CSD, see bug 1385079.
+          return false;
+        }
+        if (GdkIsWaylandDisplay()) {
+          // Disabled on wayland, see bug 1800442 and bug 1800368.
+          return false;
+        }
+        if (IsKdeDesktopEnvironment()) {
+          // Disabled on KDE, see bug 1810797.
+          return false;
+        }
+        return true;
+      }();
+      break;
+    case IntID::UseOverlayScrollbars: {
+      aResult = StaticPrefs::widget_gtk_overlay_scrollbars_enabled();
+      break;
+    }
+    case IntID::TouchDeviceSupportPresent:
+      aResult = widget::WidgetUtilsGTK::IsTouchDeviceSupportPresent() ? 1 : 0;
+      break;
+    default:
+      aResult = 0;
+      res = NS_ERROR_FAILURE;
+  }
+
+  return res;
+}
+
+nsresult nsLookAndFeel::NativeGetFloat(FloatID aID, float& aResult) {
+  nsresult rv = NS_OK;
+  switch (aID) {
+    case FloatID::IMEUnderlineRelativeSize:
+      aResult = 1.0f;
+      break;
+    case FloatID::SpellCheckerUnderlineRelativeSize:
+      aResult = 1.0f;
+      break;
+    case FloatID::CaretAspectRatio:
+      EnsureInit();
+      aResult = mSystemTheme.mCaretRatio;
+      break;
+    case FloatID::TextScaleFactor:
+      aResult = gfxPlatformGtk::GetFontScaleFactor();
+      break;
+    default:
+      aResult = -1.0;
+      rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+
+static void GetSystemFontInfo(GtkStyleContext* aStyle, nsString* aFontName,
+                              gfxFontStyle* aFontStyle) {
+  aFontStyle->style = FontSlantStyle::NORMAL;
+
+  // As in
+  // https://git.gnome.org/browse/gtk+/tree/gtk/gtkwidget.c?h=3.22.19#n10333
+  PangoFontDescription* desc;
+  gtk_style_context_get(aStyle, gtk_style_context_get_state(aStyle), "font",
+                        &desc, nullptr);
+
+  aFontStyle->systemFont = true;
+
+  constexpr auto quote = u"\""_ns;
+  NS_ConvertUTF8toUTF16 family(pango_font_description_get_family(desc));
+  *aFontName = quote + family + quote;
+
+  aFontStyle->weight =
+      FontWeight::FromInt(pango_font_description_get_weight(desc));
+
+  // FIXME: Set aFontStyle->stretch correctly!
+  aFontStyle->stretch = FontStretch::NORMAL;
+
+  float size = float(pango_font_description_get_size(desc)) / PANGO_SCALE;
+
+  // |size| is now either pixels or pango-points (not Mozilla-points!)
+
+  if (!pango_font_description_get_size_is_absolute(desc)) {
+    // |size| is in pango-points, so convert to pixels.
+    size *= float(gfxPlatformGtk::GetFontScaleDPI()) / POINTS_PER_INCH_FLOAT;
+  }
+
+  // |size| is now pixels but not scaled for the hidpi displays,
+  aFontStyle->size = size;
+
+  pango_font_description_free(desc);
+}
+
+bool nsLookAndFeel::NativeGetFont(FontID aID, nsString& aFontName,
+                                  gfxFontStyle& aFontStyle) {
+  return mSystemTheme.GetFont(aID, aFontName, aFontStyle);
+}
+
+bool nsLookAndFeel::PerThemeData::GetFont(FontID aID, nsString& aFontName,
+                                          gfxFontStyle& aFontStyle) const {
+  switch (aID) {
+    case FontID::Menu:             // css2
+    case FontID::MozPullDownMenu:  // css3
+      aFontName = mMenuFontName;
+      aFontStyle = mMenuFontStyle;
+      break;
+
+    case FontID::MozField:  // css3
+    case FontID::MozList:   // css3
+      aFontName = mFieldFontName;
+      aFontStyle = mFieldFontStyle;
+      break;
+
+    case FontID::MozButton:  // css3
+      aFontName = mButtonFontName;
+      aFontStyle = mButtonFontStyle;
+      break;
+
+    case FontID::Caption:       // css2
+    case FontID::Icon:          // css2
+    case FontID::MessageBox:    // css2
+    case FontID::SmallCaption:  // css2
+    case FontID::StatusBar:     // css2
+    default:
+      aFontName = mDefaultFontName;
+      aFontStyle = mDefaultFontStyle;
+      break;
+  }
+
+  // Convert GDK pixels to CSS pixels.
+  // When "layout.css.devPixelsPerPx" > 0, this is not a direct conversion.
+  // The difference produces a scaling of system fonts in proportion with
+  // other scaling from the change in CSS pixel sizes.
+  aFontStyle.size /= LookAndFeel::GetTextScaleFactor();
+  return true;
+}
+
+// Check color contrast according to
+// https://www.w3.org/TR/AERT/#color-contrast
+static bool HasGoodContrastVisibility(GdkRGBA& aColor1, GdkRGBA& aColor2) {
+  int32_t luminosityDifference = NS_LUMINOSITY_DIFFERENCE(
+      GDK_RGBA_TO_NS_RGBA(aColor1), GDK_RGBA_TO_NS_RGBA(aColor2));
+  if (luminosityDifference < NS_SUFFICIENT_LUMINOSITY_DIFFERENCE) {
+    return false;
+  }
+
+  double colorDifference = std::abs(aColor1.red - aColor2.red) +
+                           std::abs(aColor1.green - aColor2.green) +
+                           std::abs(aColor1.blue - aColor2.blue);
+  return (colorDifference * 255.0 > 500.0);
+}
+
+// Check if the foreground/background colors match with default white/black
+// html page colors.
+static bool IsGtkThemeCompatibleWithHTMLColors() {
+  GdkRGBA white = {1.0, 1.0, 1.0};
+  GdkRGBA black = {0.0, 0.0, 0.0};
+
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW);
+
+  GdkRGBA textColor;
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &textColor);
+
+  // Theme text color and default white html page background
+  if (!HasGoodContrastVisibility(textColor, white)) {
+    return false;
+  }
+
+  GdkRGBA backgroundColor;
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL,
+                                         &backgroundColor);
+
+  // Theme background color and default white html page background
+  if (HasGoodContrastVisibility(backgroundColor, white)) {
+    return false;
+  }
+
+  // Theme background color and default black text color
+  return HasGoodContrastVisibility(backgroundColor, black);
+}
+
+static nsCString GetGtkSettingsStringKey(const char* aKey) {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+  nsCString ret;
+  GtkSettings* settings = gtk_settings_get_default();
+  char* value = nullptr;
+  g_object_get(settings, aKey, &value, nullptr);
+  if (value) {
+    ret.Assign(value);
+    g_free(value);
+  }
+  return ret;
+}
+
+static nsCString GetGtkTheme() {
+  return GetGtkSettingsStringKey("gtk-theme-name");
+}
+
+static bool GetPreferDarkTheme() {
+  GtkSettings* settings = gtk_settings_get_default();
+  gboolean preferDarkTheme = FALSE;
+  g_object_get(settings, "gtk-application-prefer-dark-theme", &preferDarkTheme,
+               nullptr);
+  return preferDarkTheme == TRUE;
+}
+
+// It seems GTK doesn't have an API to query if the current theme is "light" or
+// "dark", so we synthesize it from the CSS2 Window/WindowText colors instead,
+// by comparing their luminosity.
+static bool GetThemeIsDark() {
+  GdkRGBA bg, fg;
+  GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &bg);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &fg);
+  return RelativeLuminanceUtils::Compute(GDK_RGBA_TO_NS_RGBA(bg)) <
+         RelativeLuminanceUtils::Compute(GDK_RGBA_TO_NS_RGBA(fg));
+}
+
+void nsLookAndFeel::ConfigureTheme(const LookAndFeelTheme& aTheme) {
+  MOZ_ASSERT(XRE_IsContentProcess());
+  GtkSettings* settings = gtk_settings_get_default();
+  g_object_set(settings, "gtk-theme-name", aTheme.themeName().get(),
+               "gtk-application-prefer-dark-theme",
+               aTheme.preferDarkTheme() ? TRUE : FALSE, nullptr);
+}
+
+void nsLookAndFeel::RestoreSystemTheme() {
+  LOGLNF("RestoreSystemTheme(%s, %d, %d)\n", mSystemTheme.mName.get(),
+         mSystemTheme.mPreferDarkTheme, mSystemThemeOverridden);
+
+  if (!mSystemThemeOverridden) {
+    return;
+  }
+
+  // Available on Gtk 3.20+.
+  static auto sGtkSettingsResetProperty =
+      (void (*)(GtkSettings*, const gchar*))dlsym(
+          RTLD_DEFAULT, "gtk_settings_reset_property");
+
+  GtkSettings* settings = gtk_settings_get_default();
+  if (sGtkSettingsResetProperty) {
+    sGtkSettingsResetProperty(settings, "gtk-theme-name");
+    sGtkSettingsResetProperty(settings, "gtk-application-prefer-dark-theme");
+  } else {
+    g_object_set(settings, "gtk-theme-name", mSystemTheme.mName.get(),
+                 "gtk-application-prefer-dark-theme",
+                 mSystemTheme.mPreferDarkTheme, nullptr);
+  }
+  moz_gtk_refresh();
+  mSystemThemeOverridden = false;
+}
+
+static bool AnyColorChannelIsDifferent(nscolor aColor) {
+  return NS_GET_R(aColor) != NS_GET_G(aColor) ||
+         NS_GET_R(aColor) != NS_GET_B(aColor);
+}
+
+void nsLookAndFeel::ConfigureAndInitializeAltTheme() {
+  GtkSettings* settings = gtk_settings_get_default();
+
+  bool fellBackToDefaultTheme = false;
+
+  // Try to select the opposite variant of the current theme first...
+  LOGLNF("    toggling gtk-application-prefer-dark-theme\n");
+  g_object_set(settings, "gtk-application-prefer-dark-theme",
+               !mSystemTheme.mIsDark, nullptr);
+  moz_gtk_refresh();
+
+  // Toggling gtk-application-prefer-dark-theme is not enough generally to
+  // switch from dark to light theme.  If the theme didn't change, and we have
+  // a dark theme, try to first remove -Dark{,er,est} from the theme name to
+  // find the light variant.
+  if (mSystemTheme.mIsDark && mSystemTheme.mIsDark == GetThemeIsDark()) {
+    nsCString potentialLightThemeName = mSystemTheme.mName;
+    // clang-format off
+    constexpr nsLiteralCString kSubstringsToRemove[] = {
+        "-darkest"_ns, "-darker"_ns, "-dark"_ns,
+        "-Darkest"_ns, "-Darker"_ns, "-Dark"_ns,
+        "_darkest"_ns, "_darker"_ns, "_dark"_ns,
+        "_Darkest"_ns, "_Darker"_ns, "_Dark"_ns,
+    };
+    // clang-format on
+    bool found = false;
+    for (auto& s : kSubstringsToRemove) {
+      potentialLightThemeName = mSystemTheme.mName;
+      potentialLightThemeName.ReplaceSubstring(s, ""_ns);
+      if (potentialLightThemeName.Length() != mSystemTheme.mName.Length()) {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      g_object_set(settings, "gtk-theme-name", potentialLightThemeName.get(),
+                   nullptr);
+      moz_gtk_refresh();
+    }
+  }
+
+  if (mSystemTheme.mIsDark == GetThemeIsDark()) {
+    // If the theme still didn't change enough, fall back to Adwaita with the
+    // appropriate color preference.
+    g_object_set(settings, "gtk-theme-name", "Adwaita",
+                 "gtk-application-prefer-dark-theme", !mSystemTheme.mIsDark,
+                 nullptr);
+    moz_gtk_refresh();
+
+    // If it _still_ didn't change enough, and we're dark, try to set
+    // Adwaita-dark as a theme name. This might be needed in older GTK versions.
+    if (!mSystemTheme.mIsDark && !GetThemeIsDark()) {
+      g_object_set(settings, "gtk-theme-name", "Adwaita-dark", nullptr);
+      moz_gtk_refresh();
+    }
+
+    fellBackToDefaultTheme = true;
+  }
+
+  mAltTheme.Init();
+
+  // Some of the alt theme colors we can grab from the system theme, if we fell
+  // back to the default light / dark themes.
+  if (fellBackToDefaultTheme) {
+    if (StaticPrefs::widget_gtk_alt_theme_selection()) {
+      mAltTheme.mTextSelectedText = mSystemTheme.mTextSelectedText;
+      mAltTheme.mTextSelectedBackground = mSystemTheme.mTextSelectedBackground;
+    }
+
+    if (StaticPrefs::widget_gtk_alt_theme_scrollbar_active() &&
+        (!mAltTheme.mIsDark || ShouldUseColorForActiveDarkScrollbarThumb(
+                                   mSystemTheme.mThemedScrollbarThumbActive))) {
+      mAltTheme.mThemedScrollbarThumbActive =
+          mSystemTheme.mThemedScrollbarThumbActive;
+    }
+
+    if (StaticPrefs::widget_gtk_alt_theme_accent()) {
+      mAltTheme.mAccentColor = mSystemTheme.mAccentColor;
+      mAltTheme.mAccentColorText = mSystemTheme.mAccentColorText;
+    }
+  }
+
+  // Special case for Adwaita: In GTK3 we don't have more proper accent colors,
+  // so we use the selected background colors. Those colors, however, don't have
+  // much contrast in dark mode (see bug 1741293). We know, however, that GTK4
+  // uses the light accent color for the dark theme, see:
+  //
+  //   https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/named-colors.html#accent-colors
+  //
+  // So we manually do that.
+  if (mSystemTheme.mName.EqualsLiteral("Adwaita") ||
+      mSystemTheme.mName.EqualsLiteral("Adwaita-dark")) {
+    auto& dark = mSystemTheme.mIsDark ? mSystemTheme : mAltTheme;
+    auto& light = mSystemTheme.mIsDark ? mAltTheme : mSystemTheme;
+
+    dark.mAccentColor = light.mAccentColor;
+    dark.mAccentColorText = light.mAccentColorText;
+  }
+
+  // Right now we're using the opposite color-scheme theme, make sure to record
+  // it.
+  mSystemThemeOverridden = true;
+}
+
+Maybe<ColorScheme> nsLookAndFeel::ComputeColorSchemeSetting() {
+  {
+    // Check the pref explicitly here. Usually this shouldn't be needed, but
+    // since we can only load one GTK theme at a time, and the pref will
+    // override the effective value that the rest of gecko assumes for the
+    // "system" color scheme, we need to factor it in our GTK theme decisions.
+    int32_t pref = 0;
+    if (NS_SUCCEEDED(Preferences::GetInt("ui.systemUsesDarkTheme", &pref))) {
+      return Some(pref ? ColorScheme::Dark : ColorScheme::Light);
+    }
+  }
+
+  if (!mDBusSettingsProxy) {
+    return Nothing();
+  }
+  GUniquePtr<GError> error;
+  RefPtr<GVariant> variant = dont_AddRef(g_dbus_proxy_call_sync(
+      mDBusSettingsProxy, "Read",
+      g_variant_new("(ss)", "org.freedesktop.appearance", "color-scheme"),
+      G_DBUS_CALL_FLAGS_NONE,
+      StaticPrefs::widget_gtk_settings_portal_timeout_ms(), nullptr,
+      getter_Transfers(error)));
+  if (!variant) {
+    LOGLNF("color-scheme query error: %s\n", error->message);
+    return Nothing();
+  }
+  LOGLNF("color-scheme query result: %s\n", GVariantToString(variant).get());
+  variant = dont_AddRef(g_variant_get_child_value(variant, 0));
+  while (variant && g_variant_is_of_type(variant, G_VARIANT_TYPE_VARIANT)) {
+    // Unbox the return value.
+    variant = dont_AddRef(g_variant_get_variant(variant));
+  }
+  if (!variant || !g_variant_is_of_type(variant, G_VARIANT_TYPE_UINT32)) {
+    MOZ_ASSERT(false, "Unexpected color-scheme query return value");
+    return Nothing();
+  }
+  switch (g_variant_get_uint32(variant)) {
+    default:
+      MOZ_FALLTHROUGH_ASSERT("Unexpected color-scheme query return value");
+    case 0:
+      break;
+    case 1:
+      return Some(ColorScheme::Dark);
+    case 2:
+      return Some(ColorScheme::Light);
+  }
+  return Nothing();
+}
+
+void nsLookAndFeel::Initialize() {
+  LOGLNF("nsLookAndFeel::Initialize");
+  MOZ_DIAGNOSTIC_ASSERT(!mInitialized);
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread(),
+                        "LookAndFeel init should be done on the main thread");
+
+  mInitialized = true;
+
+  GtkSettings* settings = gtk_settings_get_default();
+  if (MOZ_UNLIKELY(!settings)) {
+    NS_WARNING("EnsureInit: No settings");
+    return;
+  }
+
+  AutoRestore<bool> restoreIgnoreSettings(sIgnoreChangedSettings);
+  sIgnoreChangedSettings = true;
+
+  // Our current theme may be different from the system theme if we're matching
+  // the Firefox theme or using the alt theme intentionally due to the
+  // color-scheme preference. Make sure to restore the original system theme.
+  RestoreSystemTheme();
+
+  // First initialize global settings.
+  InitializeGlobalSettings();
+
+  // Record our system theme settings now.
+  mSystemTheme.Init();
+
+  // Find the alternative-scheme theme (light if the system theme is dark, or
+  // vice versa), configure it and initialize it.
+  ConfigureAndInitializeAltTheme();
+
+  LOGLNF("System Theme: %s. Alt Theme: %s\n", mSystemTheme.mName.get(),
+         mAltTheme.mName.get());
+
+  // Go back to the system theme or keep the alt theme configured, depending on
+  // Firefox theme or user color-scheme preference.
+  ConfigureFinalEffectiveTheme();
+
+  RecordTelemetry();
+}
+
+void nsLookAndFeel::InitializeGlobalSettings() {
+  GtkSettings* settings = gtk_settings_get_default();
+
+  mColorSchemePreference = ComputeColorSchemeSetting();
+
+  gboolean enableAnimations = false;
+  g_object_get(settings, "gtk-enable-animations", &enableAnimations, nullptr);
+  mPrefersReducedMotion = !enableAnimations;
+
+  gint blink_time = 0;     // In milliseconds
+  gint blink_timeout = 0;  // in seconds
+  gboolean blink;
+  g_object_get(settings, "gtk-cursor-blink-time", &blink_time,
+               "gtk-cursor-blink-timeout", &blink_timeout, "gtk-cursor-blink",
+               &blink, nullptr);
+  // From
+  // https://docs.gtk.org/gtk3/property.Settings.gtk-cursor-blink-timeout.html:
+  //
+  //     Setting this to zero has the same effect as setting
+  //     GtkSettings:gtk-cursor-blink to FALSE.
+  //
+  mCaretBlinkTime = blink && blink_timeout ? (int32_t)blink_time : 0;
+
+  if (mCaretBlinkTime) {
+    // blink_time * 2 because blink count is a full blink cycle.
+    mCaretBlinkCount =
+        std::max(1, int32_t(std::ceil(float(blink_timeout * 1000) /
+                                      (float(blink_time) * 2.0f))));
+  } else {
+    mCaretBlinkCount = -1;
+  }
+
+  mCSDCloseButton = false;
+  mCSDMinimizeButton = false;
+  mCSDMaximizeButton = false;
+  mCSDCloseButtonPosition = 0;
+  mCSDMinimizeButtonPosition = 0;
+  mCSDMaximizeButtonPosition = 0;
+
+  // We need to initialize whole CSD config explicitly because it's queried
+  // as -moz-gtk* media features.
+  ButtonLayout buttonLayout[TOOLBAR_BUTTONS];
+
+  size_t activeButtons =
+      GetGtkHeaderBarButtonLayout(Span(buttonLayout), &mCSDReversedPlacement);
+  for (size_t i = 0; i < activeButtons; i++) {
+    // We check if a button is represented on the right side of the tabbar.
+    // Then we assign it a value from 3 to 5, instead of 0 to 2 when it is on
+    // the left side.
+    const ButtonLayout& layout = buttonLayout[i];
+    int32_t* pos = nullptr;
+    switch (layout.mType) {
+      case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
+        mCSDMinimizeButton = true;
+        pos = &mCSDMinimizeButtonPosition;
+        break;
+      case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
+        mCSDMaximizeButton = true;
+        pos = &mCSDMaximizeButtonPosition;
+        break;
+      case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
+        mCSDCloseButton = true;
+        pos = &mCSDCloseButtonPosition;
+        break;
+      default:
+        break;
+    }
+
+    if (pos) {
+      *pos = i;
+    }
+  }
+}
+
+void nsLookAndFeel::ConfigureFinalEffectiveTheme() {
+  MOZ_ASSERT(mSystemThemeOverridden,
+             "By this point, the alt theme should be configured");
+
+  const bool shouldUseSystemTheme = [&] {
+    // NOTE: We can't call ColorSchemeForChrome directly because this might run
+    // while we're computing it.
+    switch (ColorSchemeSettingForChrome()) {
+      case ChromeColorSchemeSetting::Light:
+        return !mSystemTheme.mIsDark;
+      case ChromeColorSchemeSetting::Dark:
+        return mSystemTheme.mIsDark;
+      case ChromeColorSchemeSetting::System:
+        break;
+    };
+    if (!mColorSchemePreference) {
+      return true;
+    }
+    bool preferenceIsDark = *mColorSchemePreference == ColorScheme::Dark;
+    return preferenceIsDark == mSystemTheme.mIsDark;
+  }();
+
+  const bool usingSystem = !mSystemThemeOverridden;
+  LOGLNF("OverrideSystemThemeIfNeeded(matchesSystem=%d, usingSystem=%d)\n",
+         shouldUseSystemTheme, usingSystem);
+
+  if (shouldUseSystemTheme) {
+    RestoreSystemTheme();
+  } else if (usingSystem) {
+    LOGLNF("Setting theme %s, %d\n", mAltTheme.mName.get(),
+           mAltTheme.mPreferDarkTheme);
+
+    GtkSettings* settings = gtk_settings_get_default();
+    if (mSystemTheme.mName == mAltTheme.mName) {
+      // Prefer setting only gtk-application-prefer-dark-theme, so we can still
+      // get notified from notify::gtk-theme-name if the user changes the theme.
+      g_object_set(settings, "gtk-application-prefer-dark-theme",
+                   mAltTheme.mPreferDarkTheme, nullptr);
+    } else {
+      g_object_set(settings, "gtk-theme-name", mAltTheme.mName.get(),
+                   "gtk-application-prefer-dark-theme",
+                   mAltTheme.mPreferDarkTheme, nullptr);
+    }
+    moz_gtk_refresh();
+    mSystemThemeOverridden = true;
+  }
+}
+
+void nsLookAndFeel::GetGtkContentTheme(LookAndFeelTheme& aTheme) {
+  if (NS_SUCCEEDED(Preferences::GetCString("widget.content.gtk-theme-override",
+                                           aTheme.themeName()))) {
+    return;
+  }
+
+  auto& theme = StaticPrefs::widget_content_allow_gtk_dark_theme()
+                    ? mSystemTheme
+                    : LightTheme();
+  aTheme.preferDarkTheme() = theme.mPreferDarkTheme;
+  aTheme.themeName() = theme.mName;
+}
+
+static nscolor GetBackgroundColor(
+    GtkStyleContext* aStyle, nscolor aForForegroundColor,
+    GtkStateFlags aState = GTK_STATE_FLAG_NORMAL,
+    nscolor aOverBackgroundColor = NS_TRANSPARENT) {
+  GdkRGBA gdkColor;
+  gtk_style_context_get_background_color(aStyle, aState, &gdkColor);
+  nscolor color = GDK_RGBA_TO_NS_RGBA(gdkColor);
+  if (NS_GET_A(color)) {
+    if (color != aOverBackgroundColor) {
+      return color;
+    }
+  }
+
+  // Try to synthesize a color from a background-image.
+  GValue value = G_VALUE_INIT;
+  gtk_style_context_get_property(aStyle, "background-image", aState, &value);
+  auto cleanup = MakeScopeExit([&] { g_value_unset(&value); });
+
+  if (GetColorFromImagePattern(&value, &color)) {
+    return color;
+  }
+
+  {
+    GdkRGBA light, dark;
+    if (GetGradientColors(&value, &light, &dark)) {
+      nscolor l = GDK_RGBA_TO_NS_RGBA(light);
+      nscolor d = GDK_RGBA_TO_NS_RGBA(dark);
+      // Return the one with more contrast.
+      // TODO(emilio): This could do interpolation or what not but seems
+      // overkill.
+      return NS_LUMINOSITY_DIFFERENCE(l, aForForegroundColor) >
+                     NS_LUMINOSITY_DIFFERENCE(d, aForForegroundColor)
+                 ? l
+                 : d;
+    }
+  }
+
+  return NS_TRANSPARENT;
+}
+
+static bool GetNamedColorPair(GtkStyleContext* aStyle, const char* aBgName,
+                              const char* aFgName, nscolor* aBg, nscolor* aFg) {
+  GdkRGBA bg, fg;
+  if (!gtk_style_context_lookup_color(aStyle, aBgName, &bg) ||
+      !gtk_style_context_lookup_color(aStyle, aFgName, &fg)) {
+    return false;
+  }
+
+  *aBg = GDK_RGBA_TO_NS_RGBA(bg);
+  *aFg = GDK_RGBA_TO_NS_RGBA(fg);
+
+  // If the colors are semi-transparent and the theme provides a
+  // background color, blend with them to get the "final" color, see
+  // bug 1717077.
+  if (NS_GET_A(*aBg) != 255 &&
+      (gtk_style_context_lookup_color(aStyle, "bg_color", &bg) ||
+       gtk_style_context_lookup_color(aStyle, "theme_bg_color", &bg))) {
+    *aBg = NS_ComposeColors(GDK_RGBA_TO_NS_RGBA(bg), *aBg);
+  }
+
+  // A semi-transparent foreground color would be kinda silly, but is done
+  // for symmetry.
+  if (NS_GET_A(*aFg) != 255 &&
+      (gtk_style_context_lookup_color(aStyle, "fg_color", &fg) ||
+       gtk_style_context_lookup_color(aStyle, "theme_fg_color", &fg))) {
+    *aFg = NS_ComposeColors(GDK_RGBA_TO_NS_RGBA(fg), *aFg);
+  }
+
+  return true;
+}
+
+static void EnsureColorPairIsOpaque(nscolor& aBg, nscolor& aFg) {
+  // Blend with white, ensuring the color is opaque, so that the UI doesn't have
+  // to care about alpha.
+  aBg = NS_ComposeColors(NS_RGB(0xff, 0xff, 0xff), aBg);
+  aFg = NS_ComposeColors(aBg, aFg);
+}
+
+static void PreferDarkerBackground(nscolor& aBg, nscolor& aFg) {
+  // We use the darker one unless the foreground isn't really a color (is all
+  // white / black / gray) and the background is, in which case we stick to what
+  // we have.
+  if (RelativeLuminanceUtils::Compute(aBg) >
+          RelativeLuminanceUtils::Compute(aFg) &&
+      (AnyColorChannelIsDifferent(aFg) || !AnyColorChannelIsDifferent(aBg))) {
+    std::swap(aBg, aFg);
+  }
+}
+
+void nsLookAndFeel::PerThemeData::Init() {
+  mName = GetGtkTheme();
+
+  GtkStyleContext* style;
+
+  mHighContrast = StaticPrefs::widget_content_gtk_high_contrast_enabled() &&
+                  mName.Find("HighContrast"_ns) >= 0;
+
+  mPreferDarkTheme = GetPreferDarkTheme();
+
+  mIsDark = GetThemeIsDark();
+
+  mCompatibleWithHTMLLightColors =
+      !mIsDark && IsGtkThemeCompatibleWithHTMLColors();
+
+  GdkRGBA color;
+  // Some themes style the <trough>, while others style the <scrollbar>
+  // itself, so we look at both and compose the colors.
+  style = GetStyleContext(MOZ_GTK_SCROLLBAR_VERTICAL);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mThemedScrollbar = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_BACKDROP,
+                                         &color);
+  mThemedScrollbarInactive = GDK_RGBA_TO_NS_RGBA(color);
+
+  style = GetStyleContext(MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mThemedScrollbar =
+      NS_ComposeColors(mThemedScrollbar, GDK_RGBA_TO_NS_RGBA(color));
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_BACKDROP,
+                                         &color);
+  mThemedScrollbarInactive =
+      NS_ComposeColors(mThemedScrollbarInactive, GDK_RGBA_TO_NS_RGBA(color));
+
+  style = GetStyleContext(MOZ_GTK_SCROLLBAR_THUMB_VERTICAL);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mThemedScrollbarThumb = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_PRELIGHT,
+                                         &color);
+  mThemedScrollbarThumbHover = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_background_color(
+      style, GtkStateFlags(GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE),
+      &color);
+  mThemedScrollbarThumbActive = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_BACKDROP,
+                                         &color);
+  mThemedScrollbarThumbInactive = GDK_RGBA_TO_NS_RGBA(color);
+
+  // Make sure that the thumb is visible, at least.
+  const bool fallbackToUnthemedColors = [&] {
+    if (!StaticPrefs::widget_gtk_theme_scrollbar_colors_enabled()) {
+      return true;
+    }
+
+    if (!ShouldHonorThemeScrollbarColors()) {
+      return true;
+    }
+    // If any of the scrollbar thumb colors are fully transparent, fall back to
+    // non-native ones.
+    if (!NS_GET_A(mThemedScrollbarThumb) ||
+        !NS_GET_A(mThemedScrollbarThumbHover) ||
+        !NS_GET_A(mThemedScrollbarThumbActive)) {
+      return true;
+    }
+    // If the thumb and track are the same color and opaque, fall back to
+    // non-native colors as well.
+    if (mThemedScrollbar == mThemedScrollbarThumb &&
+        NS_GET_A(mThemedScrollbar) == 0xff) {
+      return true;
+    }
+    return false;
+  }();
+
+  if (fallbackToUnthemedColors) {
+    if (mIsDark) {
+      // Taken from Adwaita-dark.
+      mThemedScrollbar = NS_RGB(0x31, 0x31, 0x31);
+      mThemedScrollbarInactive = NS_RGB(0x2d, 0x2d, 0x2d);
+      mThemedScrollbarThumb = NS_RGB(0xa3, 0xa4, 0xa4);
+      mThemedScrollbarThumbInactive = NS_RGB(0x59, 0x5a, 0x5a);
+    } else {
+      // Taken from Adwaita.
+      mThemedScrollbar = NS_RGB(0xce, 0xce, 0xce);
+      mThemedScrollbarInactive = NS_RGB(0xec, 0xed, 0xef);
+      mThemedScrollbarThumb = NS_RGB(0x82, 0x81, 0x7e);
+      mThemedScrollbarThumbInactive = NS_RGB(0xce, 0xcf, 0xce);
+    }
+
+    mThemedScrollbarThumbHover = ThemeColors::AdjustUnthemedScrollbarThumbColor(
+        mThemedScrollbarThumb, dom::ElementState::HOVER);
+    mThemedScrollbarThumbActive =
+        ThemeColors::AdjustUnthemedScrollbarThumbColor(
+            mThemedScrollbarThumb, dom::ElementState::ACTIVE);
+  }
+
+  // The label is not added to a parent widget, but shared for constructing
+  // different style contexts.  The node hierarchy is constructed only on
+  // the label style context.
+  GtkWidget* labelWidget = gtk_label_new("M");
+  g_object_ref_sink(labelWidget);
+
+  // Window colors
+  style = GetStyleContext(MOZ_GTK_WINDOW);
+
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mMozWindowText = GDK_RGBA_TO_NS_RGBA(color);
+
+  mMozWindowBackground = GetBackgroundColor(style, mMozWindowText);
+
+  gtk_style_context_get_border_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mMozWindowActiveBorder = GDK_RGBA_TO_NS_RGBA(color);
+
+  gtk_style_context_get_border_color(style, GTK_STATE_FLAG_INSENSITIVE, &color);
+  mMozWindowInactiveBorder = GDK_RGBA_TO_NS_RGBA(color);
+
+  style = GetStyleContext(MOZ_GTK_WINDOW_CONTAINER);
+  {
+    GtkStyleContext* labelStyle = CreateStyleForWidget(labelWidget, style);
+    GetSystemFontInfo(labelStyle, &mDefaultFontName, &mDefaultFontStyle);
+    g_object_unref(labelStyle);
+  }
+
+  // tooltip foreground and background
+  style = GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mInfoText = GDK_RGBA_TO_NS_RGBA(color);
+
+  style = GetStyleContext(MOZ_GTK_TOOLTIP);
+  mInfoBackground = GetBackgroundColor(style, mInfoText);
+
+  style = GetStyleContext(MOZ_GTK_MENUITEM);
+  {
+    GtkStyleContext* accelStyle =
+        CreateStyleForWidget(gtk_accel_label_new("M"), style);
+
+    GetSystemFontInfo(accelStyle, &mMenuFontName, &mMenuFontStyle);
+
+    gtk_style_context_get_color(accelStyle, GTK_STATE_FLAG_NORMAL, &color);
+    mMenuText = GDK_RGBA_TO_NS_RGBA(color);
+    gtk_style_context_get_color(accelStyle, GTK_STATE_FLAG_INSENSITIVE, &color);
+    mMenuTextInactive = GDK_RGBA_TO_NS_RGBA(color);
+    g_object_unref(accelStyle);
+  }
+
+  const auto effectiveHeaderBarStyle =
+      HeaderBarShouldDrawContainer(MOZ_GTK_HEADER_BAR) ? MOZ_GTK_HEADERBAR_FIXED
+                                                       : MOZ_GTK_HEADER_BAR;
+  style = GetStyleContext(effectiveHeaderBarStyle);
+  {
+    gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+    mTitlebarText = GDK_RGBA_TO_NS_RGBA(color);
+    mTitlebarBackground = GetBackgroundColor(style, mTitlebarText);
+
+    gtk_style_context_get_color(style, GTK_STATE_FLAG_BACKDROP, &color);
+    mTitlebarInactiveText = GDK_RGBA_TO_NS_RGBA(color);
+    mTitlebarInactiveBackground =
+        GetBackgroundColor(style, mTitlebarText, GTK_STATE_FLAG_BACKDROP);
+    mTitlebarRadius = IsSolidCSDStyleUsed() ? 0 : GetBorderRadius(style);
+  }
+
+  style = GetStyleContext(MOZ_GTK_MENUPOPUP);
+  mMenuBackground = [&] {
+    nscolor color = GetBackgroundColor(style, mMenuText);
+    if (NS_GET_A(color)) {
+      return color;
+    }
+    // Some themes only style menupopups with the backdrop pseudo-class. Since a
+    // context / popup menu always seems to match that, try that before giving
+    // up.
+    color = GetBackgroundColor(style, mMenuText, GTK_STATE_FLAG_BACKDROP);
+    if (NS_GET_A(color)) {
+      return color;
+    }
+    // If we get here we couldn't figure out the right color to use. Rather than
+    // falling back to transparent, fall back to the window background.
+    NS_WARNING(
+        "Couldn't find menu background color, falling back to window "
+        "background");
+    return mMozWindowBackground;
+  }();
+  mMenuRadius = 0;
+  if (!IsSolidCSDStyleUsed()) {
+    mMenuRadius = GetBorderRadius(style);
+    if (!mMenuRadius) {
+      mMenuRadius =
+          GetBorderRadius(GetStyleContext(MOZ_GTK_MENUPOPUP_DECORATION));
+    }
+  }
+
+  style = GetStyleContext(MOZ_GTK_MENUITEM);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_PRELIGHT, &color);
+  mMenuHoverText = GDK_RGBA_TO_NS_RGBA(color);
+  mMenuHover = NS_ComposeColors(
+      mMenuBackground,
+      GetBackgroundColor(style, mMenuHoverText, GTK_STATE_FLAG_PRELIGHT,
+                         mMenuBackground));
+
+  GtkWidget* parent = gtk_fixed_new();
+  GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP);
+  GtkWidget* treeView = gtk_tree_view_new();
+  GtkWidget* linkButton = gtk_link_button_new("http://example.com/");
+  GtkWidget* menuBar = gtk_menu_bar_new();
+  GtkWidget* menuBarItem = gtk_menu_item_new();
+  GtkWidget* entry = gtk_entry_new();
+  GtkWidget* textView = gtk_text_view_new();
+
+  gtk_container_add(GTK_CONTAINER(parent), treeView);
+  gtk_container_add(GTK_CONTAINER(parent), linkButton);
+  gtk_container_add(GTK_CONTAINER(parent), menuBar);
+  gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuBarItem);
+  gtk_container_add(GTK_CONTAINER(window), parent);
+  gtk_container_add(GTK_CONTAINER(parent), entry);
+  gtk_container_add(GTK_CONTAINER(parent), textView);
+
+  // Text colors
+  GdkRGBA bgColor;
+  // If the text window background is translucent, then the background of
+  // the textview root node is visible.
+  style = GetStyleContext(MOZ_GTK_TEXT_VIEW);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL,
+                                         &bgColor);
+
+  style = GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  ApplyColorOver(color, &bgColor);
+  mFieldBackground = GDK_RGBA_TO_NS_RGBA(bgColor);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mFieldText = GDK_RGBA_TO_NS_RGBA(color);
+
+  // Selected text and background
+  {
+    GtkStyleContext* selectionStyle =
+        GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT_SELECTION);
+    auto GrabSelectionColors = [&](GtkStyleContext* style) {
+      gtk_style_context_get_background_color(
+          style,
+          static_cast<GtkStateFlags>(GTK_STATE_FLAG_FOCUSED |
+                                     GTK_STATE_FLAG_SELECTED),
+          &color);
+      mTextSelectedBackground = GDK_RGBA_TO_NS_RGBA(color);
+      gtk_style_context_get_color(
+          style,
+          static_cast<GtkStateFlags>(GTK_STATE_FLAG_FOCUSED |
+                                     GTK_STATE_FLAG_SELECTED),
+          &color);
+      mTextSelectedText = GDK_RGBA_TO_NS_RGBA(color);
+    };
+    GrabSelectionColors(selectionStyle);
+    if (mTextSelectedBackground == mTextSelectedText) {
+      // Some old distros/themes don't properly use the .selection style, so
+      // fall back to the regular text view style.
+      GrabSelectionColors(style);
+    }
+
+    // Default selected item color is the selection background / foreground
+    // colors, but we prefer named colors, as those are more general purpose
+    // than the actual selection style, which might e.g. be too-transparent.
+    //
+    // NOTE(emilio): It's unclear which one of the theme_selected_* or the
+    // selected_* pairs should we prefer, in all themes that define both that
+    // I've found, they're always the same.
+    if (!GetNamedColorPair(style, "selected_bg_color", "selected_fg_color",
+                           &mSelectedItem, &mSelectedItemText) &&
+        !GetNamedColorPair(style, "theme_selected_bg_color",
+                           "theme_selected_fg_color", &mSelectedItem,
+                           &mSelectedItemText)) {
+      mSelectedItem = mTextSelectedBackground;
+      mSelectedItemText = mTextSelectedText;
+    }
+
+    EnsureColorPairIsOpaque(mSelectedItem, mSelectedItemText);
+
+    // In a similar fashion, default accent color is the selected item/text
+    // pair, but we also prefer named colors, if available.
+    //
+    // accent_{bg,fg}_color is not _really_ a gtk3 thing (it's a gtk4 thing),
+    // but if gtk 3 themes want to specify these we let them, see:
+    //
+    //   https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/named-colors.html#accent-colors
+    if (!GetNamedColorPair(style, "accent_bg_color", "accent_fg_color",
+                           &mAccentColor, &mAccentColorText)) {
+      mAccentColor = mSelectedItem;
+      mAccentColorText = mSelectedItemText;
+    }
+
+    EnsureColorPairIsOpaque(mAccentColor, mAccentColorText);
+    PreferDarkerBackground(mAccentColor, mAccentColorText);
+  }
+
+  // Button text color
+  style = GetStyleContext(MOZ_GTK_BUTTON);
+  {
+    GtkStyleContext* labelStyle = CreateStyleForWidget(labelWidget, style);
+    GetSystemFontInfo(labelStyle, &mButtonFontName, &mButtonFontStyle);
+    g_object_unref(labelStyle);
+  }
+
+  gtk_style_context_get_border_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mButtonDefault = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mButtonText = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_PRELIGHT, &color);
+  mButtonHoverText = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_ACTIVE, &color);
+  mButtonActiveText = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_PRELIGHT,
+                                         &color);
+  mButtonHoverFace = GDK_RGBA_TO_NS_RGBA(color);
+  if (!NS_GET_A(mButtonHoverFace)) {
+    mButtonHoverFace = mMozWindowBackground;
+  }
+
+  // Combobox text color
+  style = GetStyleContext(MOZ_GTK_COMBOBOX_ENTRY_TEXTAREA);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mComboBoxText = GDK_RGBA_TO_NS_RGBA(color);
+
+  // Menubar text and hover text colors
+  style = GetStyleContext(MOZ_GTK_MENUBARITEM);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mMenuBarText = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_PRELIGHT, &color);
+  mMenuBarHoverText = GDK_RGBA_TO_NS_RGBA(color);
+
+  // GTK's guide to fancy odd row background colors:
+  // 1) Check if a theme explicitly defines an odd row color
+  // 2) If not, check if it defines an even row color, and darken it
+  //    slightly by a hardcoded value (gtkstyle.c)
+  // 3) If neither are defined, take the base background color and
+  //    darken that by a hardcoded value
+  style = GetStyleContext(MOZ_GTK_TREEVIEW);
+
+  // Get odd row background color
+  gtk_style_context_save(style);
+  gtk_style_context_add_region(style, GTK_STYLE_REGION_ROW, GTK_REGION_ODD);
+  gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mOddCellBackground = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_restore(style);
+
+  // Column header colors
+  style = GetStyleContext(MOZ_GTK_TREE_HEADER_CELL);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
+  mMozColHeaderText = GDK_RGBA_TO_NS_RGBA(color);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_PRELIGHT, &color);
+  mMozColHeaderHoverText = GDK_RGBA_TO_NS_RGBA(color);
+
+  // Compute cell highlight colors
+  InitCellHighlightColors();
+
+  // GtkFrame has a "border" subnode on which Adwaita draws the border.
+  // Some themes do not draw on this node but draw a border on the widget
+  // root node, so check the root node if no border is found on the border
+  // node.
+  style = GetStyleContext(MOZ_GTK_FRAME_BORDER);
+  bool themeUsesColors =
+      GetBorderColors(style, &mFrameOuterLightBorder, &mFrameInnerDarkBorder);
+  if (!themeUsesColors) {
+    style = GetStyleContext(MOZ_GTK_FRAME);
+    GetBorderColors(style, &mFrameOuterLightBorder, &mFrameInnerDarkBorder);
+  }
+
+  // Some themes have a unified menu bar, and support window dragging on it
+  gboolean supports_menubar_drag = FALSE;
+  GParamSpec* param_spec = gtk_widget_class_find_style_property(
+      GTK_WIDGET_GET_CLASS(menuBar), "window-dragging");
+  if (param_spec) {
+    if (g_type_is_a(G_PARAM_SPEC_VALUE_TYPE(param_spec), G_TYPE_BOOLEAN)) {
+      gtk_widget_style_get(menuBar, "window-dragging", &supports_menubar_drag,
+                           nullptr);
+    }
+  }
+  mMenuSupportsDrag = supports_menubar_drag;
+
+  // TODO: It returns wrong color for themes which
+  // sets link color for GtkLabel only as we query
+  // GtkLinkButton style here.
+  style = gtk_widget_get_style_context(linkButton);
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_LINK, &color);
+  mNativeHyperLinkText = GDK_RGBA_TO_NS_RGBA(color);
+
+  gtk_style_context_get_color(style, GTK_STATE_FLAG_VISITED, &color);
+  mNativeVisitedHyperLinkText = GDK_RGBA_TO_NS_RGBA(color);
+
+  // invisible character styles
+  guint value;
+  g_object_get(entry, "invisible-char", &value, nullptr);
+  mInvisibleCharacter = char16_t(value);
+
+  // caret styles
+  gtk_widget_style_get(entry, "cursor-aspect-ratio", &mCaretRatio, nullptr);
+
+  GetSystemFontInfo(gtk_widget_get_style_context(entry), &mFieldFontName,
+                    &mFieldFontStyle);
+
+  gtk_widget_destroy(window);
+  g_object_unref(labelWidget);
+
+  if (LOGLNF_ENABLED()) {
+    LOGLNF("Initialized theme %s (%d)\n", mName.get(), mPreferDarkTheme);
+    for (auto id : MakeEnumeratedRange(ColorID::End)) {
+      nscolor color;
+      nsresult rv = GetColor(id, color);
+      LOGLNF(" * color %d: pref=%s success=%d value=%x\n", int(id),
+             GetColorPrefName(id), NS_SUCCEEDED(rv),
+             NS_SUCCEEDED(rv) ? color : 0);
+    }
+    LOGLNF(" * titlebar-radius: %d\n", mTitlebarRadius);
+    LOGLNF(" * menu-radius: %d\n", mMenuRadius);
+  }
+}
+
+// virtual
+char16_t nsLookAndFeel::GetPasswordCharacterImpl() {
+  EnsureInit();
+  return mSystemTheme.mInvisibleCharacter;
+}
+
+bool nsLookAndFeel::GetEchoPasswordImpl() { return false; }
+
+bool nsLookAndFeel::GetDefaultDrawInTitlebar() {
+  static bool drawInTitlebar = []() {
+    // When user defined widget.default-hidden-titlebar don't do any
+    // heuristics and just follow it.
+    if (Preferences::HasUserValue("widget.default-hidden-titlebar")) {
+      return Preferences::GetBool("widget.default-hidden-titlebar", false);
+    }
+
+    // Don't hide titlebar when it's disabled on current desktop.
+    if (!sCSDAvailable) {
+      return false;
+    }
+
+    // We hide system titlebar on Gnome/ElementaryOS without any restriction.
+    return IsGnomeDesktopEnvironment() ||
+           FindInReadable("pantheon"_ns, GetDesktopEnvironmentIdentifier());
+  }();
+  return drawInTitlebar;
+}
+
+void nsLookAndFeel::GetThemeInfo(nsACString& aInfo) {
+  aInfo.Append(mSystemTheme.mName);
+  aInfo.Append(" / ");
+  aInfo.Append(mAltTheme.mName);
+}
+
+bool nsLookAndFeel::WidgetUsesImage(WidgetNodeType aNodeType) {
+  static constexpr GtkStateFlags sFlagsToCheck[]{
+      GTK_STATE_FLAG_NORMAL, GTK_STATE_FLAG_PRELIGHT,
+      GtkStateFlags(GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE),
+      GTK_STATE_FLAG_BACKDROP, GTK_STATE_FLAG_INSENSITIVE};
+
+  GtkStyleContext* style = GetStyleContext(aNodeType);
+
+  GValue value = G_VALUE_INIT;
+  for (GtkStateFlags state : sFlagsToCheck) {
+    gtk_style_context_get_property(style, "background-image", state, &value);
+    bool hasPattern = G_VALUE_TYPE(&value) == CAIRO_GOBJECT_TYPE_PATTERN &&
+                      g_value_get_boxed(&value);
+    g_value_unset(&value);
+    if (hasPattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void nsLookAndFeel::RecordLookAndFeelSpecificTelemetry() {
+  // Gtk version we're on.
+  nsString version;
+  version.AppendPrintf("%d.%d", gtk_major_version, gtk_minor_version);
+  Telemetry::ScalarSet(Telemetry::ScalarID::WIDGET_GTK_VERSION, version);
+
+  // Whether the current Gtk theme has scrollbar buttons.
+  bool hasScrollbarButtons =
+      GetInt(LookAndFeel::IntID::ScrollArrowStyle) != eScrollArrow_None;
+  mozilla::Telemetry::ScalarSet(
+      mozilla::Telemetry::ScalarID::WIDGET_GTK_THEME_HAS_SCROLLBAR_BUTTONS,
+      hasScrollbarButtons);
+
+  // Whether the current Gtk theme uses something other than a solid color
+  // background for scrollbar parts.
+  bool scrollbarUsesImage = !ShouldHonorThemeScrollbarColors();
+  mozilla::Telemetry::ScalarSet(
+      mozilla::Telemetry::ScalarID::WIDGET_GTK_THEME_SCROLLBAR_USES_IMAGES,
+      scrollbarUsesImage);
+}
+
+bool nsLookAndFeel::ShouldHonorThemeScrollbarColors() {
+  // If the Gtk theme uses anything other than solid color backgrounds for Gtk
+  // scrollbar parts, this is a good indication that painting XUL scrollbar part
+  // elements using colors extracted from the theme won't provide good results.
+  return !WidgetUsesImage(MOZ_GTK_SCROLLBAR_VERTICAL) &&
+         !WidgetUsesImage(MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL) &&
+         !WidgetUsesImage(MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL) &&
+         !WidgetUsesImage(MOZ_GTK_SCROLLBAR_THUMB_VERTICAL);
+}
+
+#undef LOGLNF
+#undef LOGLNF_ENABLED
diff --git a/widget/gtk/nsLookAndFeel.h b/widget/gtk/nsLookAndFeel.h
new file mode 100644
index 0000000000..abf5eb2bf8
--- /dev/null
+++ b/widget/gtk/nsLookAndFeel.h
@@ -0,0 +1,185 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsLookAndFeel
+#define __nsLookAndFeel
+
+#include "X11UndefineNone.h"
+#include "nsXPLookAndFeel.h"
+#include "nsCOMPtr.h"
+#include "gfxFont.h"
+
+enum WidgetNodeType : int;
+struct _GtkStyle;
+typedef struct _GDBusProxy GDBusProxy;
+
+class nsLookAndFeel final : public nsXPLookAndFeel {
+ public:
+  nsLookAndFeel();
+  virtual ~nsLookAndFeel();
+
+  void NativeInit() final;
+  void RefreshImpl() override;
+  nsresult NativeGetInt(IntID aID, int32_t& aResult) override;
+  nsresult NativeGetFloat(FloatID aID, float& aResult) override;
+  nsresult NativeGetColor(ColorID, ColorScheme, nscolor& aResult) override;
+  bool NativeGetFont(FontID aID, nsString& aFontName,
+                     gfxFontStyle& aFontStyle) override;
+
+  char16_t GetPasswordCharacterImpl() override;
+  bool GetEchoPasswordImpl() override;
+
+  bool GetDefaultDrawInTitlebar() override;
+
+  void GetGtkContentTheme(LookAndFeelTheme&) override;
+  void GetThemeInfo(nsACString&) override;
+
+  static void ConfigureTheme(const LookAndFeelTheme& aTheme);
+
+  static const nscolor kBlack = NS_RGB(0, 0, 0);
+  static const nscolor kWhite = NS_RGB(255, 255, 255);
+
+ protected:
+  static bool WidgetUsesImage(WidgetNodeType aNodeType);
+  void RecordLookAndFeelSpecificTelemetry() override;
+  static bool ShouldHonorThemeScrollbarColors();
+  mozilla::Maybe<ColorScheme> ComputeColorSchemeSetting();
+
+  // We use up to two themes (one light, one dark), which might have different
+  // sets of fonts and colors.
+  struct PerThemeData {
+    nsCString mName;
+
+    bool mIsDark = false;
+    bool mHighContrast = false;
+    bool mPreferDarkTheme = false;
+
+    // NOTE(emilio): This is unused, but if we need to we can use it to override
+    // system colors with standins like we do for the non-native theme.
+    bool mCompatibleWithHTMLLightColors = false;
+
+    // Cached fonts
+    nsString mDefaultFontName;
+    nsString mButtonFontName;
+    nsString mFieldFontName;
+    nsString mMenuFontName;
+    gfxFontStyle mDefaultFontStyle;
+    gfxFontStyle mButtonFontStyle;
+    gfxFontStyle mFieldFontStyle;
+    gfxFontStyle mMenuFontStyle;
+
+    // Cached colors
+    nscolor mInfoBackground = kWhite;
+    nscolor mInfoText = kBlack;
+    nscolor mMenuBackground = kWhite;
+    nscolor mMenuBarText = kBlack;
+    nscolor mMenuBarHoverText = kBlack;
+    nscolor mMenuText = kBlack;
+    nscolor mMenuTextInactive = kWhite;
+    nscolor mMenuHover = kWhite;
+    nscolor mMenuHoverText = kBlack;
+    nscolor mButtonDefault = kWhite;
+    nscolor mButtonText = kBlack;
+    nscolor mButtonHoverText = kBlack;
+    nscolor mButtonHoverFace = kWhite;
+    nscolor mButtonActiveText = kBlack;
+    nscolor mFrameOuterLightBorder = kBlack;
+    nscolor mFrameInnerDarkBorder = kBlack;
+    nscolor mOddCellBackground = kWhite;
+    nscolor mNativeHyperLinkText = kBlack;
+    nscolor mNativeVisitedHyperLinkText = kBlack;
+    nscolor mComboBoxText = kBlack;
+    nscolor mComboBoxBackground = kWhite;
+    nscolor mFieldText = kBlack;
+    nscolor mFieldBackground = kWhite;
+    nscolor mMozWindowText = kBlack;
+    nscolor mMozWindowBackground = kWhite;
+    nscolor mMozWindowActiveBorder = kBlack;
+    nscolor mMozWindowInactiveBorder = kBlack;
+    nscolor mMozCellHighlightBackground = kWhite;
+    nscolor mMozCellHighlightText = kBlack;
+    nscolor mTextSelectedText = kBlack;
+    nscolor mTextSelectedBackground = kWhite;
+    nscolor mAccentColor = kWhite;
+    nscolor mAccentColorText = kWhite;
+    nscolor mSelectedItem = kWhite;
+    nscolor mSelectedItemText = kBlack;
+    nscolor mMozColHeaderText = kBlack;
+    nscolor mMozColHeaderHoverText = kBlack;
+    nscolor mTitlebarText = kBlack;
+    nscolor mTitlebarBackground = kWhite;
+    nscolor mTitlebarInactiveText = kBlack;
+    nscolor mTitlebarInactiveBackground = kWhite;
+    nscolor mThemedScrollbar = kWhite;
+    nscolor mThemedScrollbarInactive = kWhite;
+    nscolor mThemedScrollbarThumb = kBlack;
+    nscolor mThemedScrollbarThumbHover = kBlack;
+    nscolor mThemedScrollbarThumbActive = kBlack;
+    nscolor mThemedScrollbarThumbInactive = kBlack;
+
+    float mCaretRatio = 0.0f;
+    int32_t mTitlebarRadius = 0;
+    int32_t mMenuRadius = 0;
+    char16_t mInvisibleCharacter = 0;
+    bool mMenuSupportsDrag = false;
+
+    void Init();
+    nsresult GetColor(ColorID, nscolor&) const;
+    bool GetFont(FontID, nsString& aFontName, gfxFontStyle&) const;
+    void InitCellHighlightColors();
+  };
+
+  PerThemeData mSystemTheme;
+
+  // If the system theme is light, a dark theme. Otherwise, a light theme. The
+  // alternative theme to the current one is preferred, but otherwise we fall
+  // back to Adwaita / Adwaita Dark, respectively.
+  PerThemeData mAltTheme;
+
+  const PerThemeData& LightTheme() const {
+    return mSystemTheme.mIsDark ? mAltTheme : mSystemTheme;
+  }
+
+  const PerThemeData& DarkTheme() const {
+    return mSystemTheme.mIsDark ? mSystemTheme : mAltTheme;
+  }
+
+  const PerThemeData& EffectiveTheme() const {
+    return mSystemThemeOverridden ? mAltTheme : mSystemTheme;
+  }
+
+  RefPtr<GDBusProxy> mDBusSettingsProxy;
+  mozilla::Maybe<ColorScheme> mColorSchemePreference;
+  int32_t mCaretBlinkTime = 0;
+  int32_t mCaretBlinkCount = -1;
+  bool mCSDMaximizeButton = false;
+  bool mCSDMinimizeButton = false;
+  bool mCSDCloseButton = false;
+  bool mCSDReversedPlacement = false;
+  bool mPrefersReducedMotion = false;
+  bool mInitialized = false;
+  bool mSystemThemeOverridden = false;
+  int32_t mCSDMaximizeButtonPosition = 0;
+  int32_t mCSDMinimizeButtonPosition = 0;
+  int32_t mCSDCloseButtonPosition = 0;
+
+  void EnsureInit() {
+    if (mInitialized) {
+      return;
+    }
+    Initialize();
+  }
+
+  void Initialize();
+
+  void RestoreSystemTheme();
+  void InitializeGlobalSettings();
+  void ConfigureAndInitializeAltTheme();
+  void ConfigureFinalEffectiveTheme();
+};
+
+#endif
diff --git a/widget/gtk/nsNativeThemeGTK.cpp b/widget/gtk/nsNativeThemeGTK.cpp
new file mode 100644
index 0000000000..28d51205e5
--- /dev/null
+++ b/widget/gtk/nsNativeThemeGTK.cpp
@@ -0,0 +1,1611 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsNativeThemeGTK.h"
+#include "nsStyleConsts.h"
+#include "gtkdrawing.h"
+#include "ScreenHelperGTK.h"
+#include "WidgetUtilsGtk.h"
+
+#include "gfx2DGlue.h"
+#include "nsIObserverService.h"
+#include "nsIFrame.h"
+#include "nsIContent.h"
+#include "nsViewManager.h"
+#include "nsNameSpaceManager.h"
+#include "nsGfxCIID.h"
+#include "nsTransform2D.h"
+#include "nsXULPopupManager.h"
+#include "tree/nsTreeBodyFrame.h"
+#include "prlink.h"
+#include "nsGkAtoms.h"
+#include "nsAttrValueInlines.h"
+
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Services.h"
+
+#include <gdk/gdkprivate.h>
+#include <gtk/gtk.h>
+
+#include "gfxContext.h"
+#include "mozilla/dom/XULButtonElement.h"
+#include "mozilla/gfx/BorrowedContext.h"
+#include "mozilla/gfx/HelpersCairo.h"
+#include "mozilla/gfx/PathHelpers.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "nsWindow.h"
+#include "nsLayoutUtils.h"
+#include "Theme.h"
+
+#ifdef MOZ_X11
+#  ifdef CAIRO_HAS_XLIB_SURFACE
+#    include "cairo-xlib.h"
+#  endif
+#endif
+
+#include <algorithm>
+#include <dlfcn.h>
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::widget;
+
+static int gLastGdkError;
+
+// Return scale factor of the monitor where the window is located
+// by the most part or layout.css.devPixelsPerPx pref if set to > 0.
+static inline gint GetMonitorScaleFactor(nsPresContext* aPresContext) {
+  nsCOMPtr<nsIWidget> rootWidget = aPresContext->GetRootWidget();
+  auto scale = rootWidget ? rootWidget->GetDefaultScale()
+                          : aPresContext->CSSToDevPixelScale();
+  // We prefer the root widget scale since it doesn't account for text scale
+  // factor, this is the same scrollbars do in GTK.
+  int monitorScale = int(round(scale.scale));
+  // When the layout.css.devPixelsPerPx is set the scale can be < 1, the real
+  // monitor scale cannot go under 1.
+  return std::max(1, monitorScale);
+}
+
+static inline gint GetMonitorScaleFactor(nsIFrame* aFrame) {
+  return GetMonitorScaleFactor(aFrame->PresContext());
+}
+
+nsNativeThemeGTK::nsNativeThemeGTK() : Theme(ScrollbarStyle()) {
+  if (moz_gtk_init() != MOZ_GTK_SUCCESS) {
+    memset(mDisabledWidgetTypes, 0xff, sizeof(mDisabledWidgetTypes));
+    return;
+  }
+
+  ThemeChanged();
+}
+
+nsNativeThemeGTK::~nsNativeThemeGTK() { moz_gtk_shutdown(); }
+
+void nsNativeThemeGTK::RefreshWidgetWindow(nsIFrame* aFrame) {
+  MOZ_ASSERT(aFrame);
+  MOZ_ASSERT(aFrame->PresShell());
+
+  nsViewManager* vm = aFrame->PresShell()->GetViewManager();
+  if (!vm) {
+    return;
+  }
+  vm->InvalidateAllViews();
+}
+
+static bool IsFrameContentNodeInNamespace(nsIFrame* aFrame,
+                                          uint32_t aNamespace) {
+  nsIContent* content = aFrame ? aFrame->GetContent() : nullptr;
+  if (!content) return false;
+  return content->IsInNamespace(aNamespace);
+}
+
+static bool IsWidgetTypeDisabled(const uint8_t* aDisabledVector,
+                                 StyleAppearance aAppearance) {
+  auto type = static_cast<size_t>(aAppearance);
+  MOZ_ASSERT(type < static_cast<size_t>(StyleAppearance::Count));
+  return (aDisabledVector[type >> 3] & (1 << (type & 7))) != 0;
+}
+
+static void SetWidgetTypeDisabled(uint8_t* aDisabledVector,
+                                  StyleAppearance aAppearance) {
+  auto type = static_cast<size_t>(aAppearance);
+  MOZ_ASSERT(type < static_cast<size_t>(mozilla::StyleAppearance::Count));
+  aDisabledVector[type >> 3] |= (1 << (type & 7));
+}
+
+static inline uint16_t GetWidgetStateKey(StyleAppearance aAppearance,
+                                         GtkWidgetState* aWidgetState) {
+  return (aWidgetState->active | aWidgetState->focused << 1 |
+          aWidgetState->inHover << 2 | aWidgetState->disabled << 3 |
+          aWidgetState->isDefault << 4 |
+          static_cast<uint16_t>(aAppearance) << 5);
+}
+
+static bool IsWidgetStateSafe(uint8_t* aSafeVector, StyleAppearance aAppearance,
+                              GtkWidgetState* aWidgetState) {
+  MOZ_ASSERT(static_cast<size_t>(aAppearance) <
+             static_cast<size_t>(mozilla::StyleAppearance::Count));
+  uint16_t key = GetWidgetStateKey(aAppearance, aWidgetState);
+  return (aSafeVector[key >> 3] & (1 << (key & 7))) != 0;
+}
+
+static void SetWidgetStateSafe(uint8_t* aSafeVector,
+                               StyleAppearance aAppearance,
+                               GtkWidgetState* aWidgetState) {
+  MOZ_ASSERT(static_cast<size_t>(aAppearance) <
+             static_cast<size_t>(mozilla::StyleAppearance::Count));
+  uint16_t key = GetWidgetStateKey(aAppearance, aWidgetState);
+  aSafeVector[key >> 3] |= (1 << (key & 7));
+}
+
+/* static */
+GtkTextDirection nsNativeThemeGTK::GetTextDirection(nsIFrame* aFrame) {
+  // IsFrameRTL() treats vertical-rl modes as right-to-left (in addition to
+  // horizontal text with direction=RTL), rather than just considering the
+  // text direction.  GtkTextDirection does not have distinct values for
+  // vertical writing modes, but considering the block flow direction is
+  // important for resizers and scrollbar elements, at least.
+  return IsFrameRTL(aFrame) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
+}
+
+// Returns positive for negative margins (otherwise 0).
+gint nsNativeThemeGTK::GetTabMarginPixels(nsIFrame* aFrame) {
+  nscoord margin = IsBottomTab(aFrame) ? aFrame->GetUsedMargin().top
+                                       : aFrame->GetUsedMargin().bottom;
+
+  return std::min<gint>(
+      MOZ_GTK_TAB_MARGIN_MASK,
+      std::max(0, aFrame->PresContext()->AppUnitsToDevPixels(-margin)));
+}
+
+bool nsNativeThemeGTK::GetGtkWidgetAndState(StyleAppearance aAppearance,
+                                            nsIFrame* aFrame,
+                                            WidgetNodeType& aGtkWidgetType,
+                                            GtkWidgetState* aState,
+                                            gint* aWidgetFlags) {
+  if (aWidgetFlags) {
+    *aWidgetFlags = 0;
+  }
+
+  ElementState elementState = GetContentState(aFrame, aAppearance);
+  if (aState) {
+    memset(aState, 0, sizeof(GtkWidgetState));
+
+    // For XUL checkboxes and radio buttons, the state of the parent
+    // determines our state.
+    if (aWidgetFlags) {
+      if (elementState.HasState(ElementState::CHECKED)) {
+        *aWidgetFlags |= MOZ_GTK_WIDGET_CHECKED;
+      }
+      if (elementState.HasState(ElementState::INDETERMINATE)) {
+        *aWidgetFlags |= MOZ_GTK_WIDGET_INCONSISTENT;
+      }
+    }
+
+    aState->disabled =
+        elementState.HasState(ElementState::DISABLED) || IsReadOnly(aFrame);
+    aState->active = elementState.HasState(ElementState::ACTIVE);
+    aState->focused = elementState.HasState(ElementState::FOCUS);
+    aState->inHover = elementState.HasState(ElementState::HOVER);
+    aState->isDefault = IsDefaultButton(aFrame);
+    aState->canDefault = FALSE;  // XXX fix me
+
+    if (aAppearance == StyleAppearance::FocusOutline) {
+      aState->disabled = FALSE;
+      aState->active = FALSE;
+      aState->inHover = FALSE;
+      aState->isDefault = FALSE;
+      aState->canDefault = FALSE;
+
+      aState->focused = TRUE;
+      aState->depressed = TRUE;  // see moz_gtk_entry_paint()
+    } else if (aAppearance == StyleAppearance::Button ||
+               aAppearance == StyleAppearance::Toolbarbutton ||
+               aAppearance == StyleAppearance::Dualbutton ||
+               aAppearance == StyleAppearance::ToolbarbuttonDropdown ||
+               aAppearance == StyleAppearance::Menulist ||
+               aAppearance == StyleAppearance::MenulistButton ||
+               aAppearance == StyleAppearance::MozMenulistArrowButton) {
+      aState->active &= aState->inHover;
+    } else if (aAppearance == StyleAppearance::Treetwisty ||
+               aAppearance == StyleAppearance::Treetwistyopen) {
+      nsTreeBodyFrame* treeBodyFrame = do_QueryFrame(aFrame);
+      if (treeBodyFrame) {
+        const mozilla::AtomArray& atoms =
+            treeBodyFrame->GetPropertyArrayForCurrentDrawingItem();
+        aState->selected = atoms.Contains((nsStaticAtom*)nsGkAtoms::selected);
+        aState->inHover = atoms.Contains((nsStaticAtom*)nsGkAtoms::hover);
+      }
+    }
+
+    if (IsFrameContentNodeInNamespace(aFrame, kNameSpaceID_XUL)) {
+      // For these widget types, some element (either a child or parent)
+      // actually has element focus, so we check the focused attribute
+      // to see whether to draw in the focused state.
+      aState->focused = elementState.HasState(ElementState::FOCUSRING);
+      if (aAppearance == StyleAppearance::Radio ||
+          aAppearance == StyleAppearance::Checkbox) {
+        // In XUL, checkboxes and radios shouldn't have focus rings, their
+        // labels do
+        aState->focused = FALSE;
+      }
+
+      // menu item state is determined by the attribute "_moz-menuactive",
+      // and not by the mouse hovering (accessibility).  as a special case,
+      // menus which are children of a menu bar are only marked as prelight
+      // if they are open, not on normal hover.
+
+      if (aAppearance == StyleAppearance::Menuitem ||
+          aAppearance == StyleAppearance::Checkmenuitem ||
+          aAppearance == StyleAppearance::Radiomenuitem ||
+          aAppearance == StyleAppearance::Menuseparator ||
+          aAppearance == StyleAppearance::Menuarrow) {
+        auto* item = dom::XULButtonElement::FromNode(aFrame->GetContent());
+        if (item && item->IsOnMenuBar()) {
+          aState->inHover = CheckBooleanAttr(aFrame, nsGkAtoms::open);
+        } else {
+          aState->inHover = CheckBooleanAttr(aFrame, nsGkAtoms::menuactive);
+        }
+
+        aState->active = FALSE;
+
+        if (aAppearance == StyleAppearance::Checkmenuitem ||
+            aAppearance == StyleAppearance::Radiomenuitem) {
+          *aWidgetFlags = 0;
+          if (aFrame && aFrame->GetContent() &&
+              aFrame->GetContent()->IsElement()) {
+            *aWidgetFlags = aFrame->GetContent()->AsElement()->AttrValueIs(
+                kNameSpaceID_None, nsGkAtoms::checked, nsGkAtoms::_true,
+                eIgnoreCase);
+          }
+        }
+      }
+
+      // A button with drop down menu open or an activated toggle button
+      // should always appear depressed.
+      if (aAppearance == StyleAppearance::Button ||
+          aAppearance == StyleAppearance::Toolbarbutton ||
+          aAppearance == StyleAppearance::Dualbutton ||
+          aAppearance == StyleAppearance::ToolbarbuttonDropdown ||
+          aAppearance == StyleAppearance::Menulist ||
+          aAppearance == StyleAppearance::MenulistButton ||
+          aAppearance == StyleAppearance::MozMenulistArrowButton) {
+        bool menuOpen = IsOpenButton(aFrame);
+        aState->depressed = IsCheckedButton(aFrame) || menuOpen;
+        // we must not highlight buttons with open drop down menus on hover.
+        aState->inHover = aState->inHover && !menuOpen;
+      }
+
+      // When the input field of the drop down button has focus, some themes
+      // should draw focus for the drop down button as well.
+      if ((aAppearance == StyleAppearance::MenulistButton ||
+           aAppearance == StyleAppearance::MozMenulistArrowButton) &&
+          aWidgetFlags) {
+        *aWidgetFlags = CheckBooleanAttr(aFrame, nsGkAtoms::parentfocused);
+      }
+    }
+
+    if (aAppearance == StyleAppearance::MozWindowTitlebar ||
+        aAppearance == StyleAppearance::MozWindowTitlebarMaximized ||
+        aAppearance == StyleAppearance::MozWindowButtonClose ||
+        aAppearance == StyleAppearance::MozWindowButtonMinimize ||
+        aAppearance == StyleAppearance::MozWindowButtonMaximize ||
+        aAppearance == StyleAppearance::MozWindowButtonRestore) {
+      aState->backdrop = !nsWindow::GetTopLevelWindowActiveState(aFrame);
+    }
+  }
+
+  switch (aAppearance) {
+    case StyleAppearance::Button:
+      if (aWidgetFlags) *aWidgetFlags = GTK_RELIEF_NORMAL;
+      aGtkWidgetType = MOZ_GTK_BUTTON;
+      break;
+    case StyleAppearance::Toolbarbutton:
+    case StyleAppearance::Dualbutton:
+      if (aWidgetFlags) *aWidgetFlags = GTK_RELIEF_NONE;
+      aGtkWidgetType = MOZ_GTK_TOOLBAR_BUTTON;
+      break;
+    case StyleAppearance::FocusOutline:
+      aGtkWidgetType = MOZ_GTK_ENTRY;
+      break;
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::Radio:
+      aGtkWidgetType = (aAppearance == StyleAppearance::Radio)
+                           ? MOZ_GTK_RADIOBUTTON
+                           : MOZ_GTK_CHECKBUTTON;
+      break;
+    case StyleAppearance::Spinner:
+      aGtkWidgetType = MOZ_GTK_SPINBUTTON;
+      break;
+    case StyleAppearance::SpinnerUpbutton:
+      aGtkWidgetType = MOZ_GTK_SPINBUTTON_UP;
+      break;
+    case StyleAppearance::SpinnerDownbutton:
+      aGtkWidgetType = MOZ_GTK_SPINBUTTON_DOWN;
+      break;
+    case StyleAppearance::SpinnerTextfield:
+      aGtkWidgetType = MOZ_GTK_SPINBUTTON_ENTRY;
+      break;
+    case StyleAppearance::Range: {
+      if (IsRangeHorizontal(aFrame)) {
+        if (aWidgetFlags) *aWidgetFlags = GTK_ORIENTATION_HORIZONTAL;
+        aGtkWidgetType = MOZ_GTK_SCALE_HORIZONTAL;
+      } else {
+        if (aWidgetFlags) *aWidgetFlags = GTK_ORIENTATION_VERTICAL;
+        aGtkWidgetType = MOZ_GTK_SCALE_VERTICAL;
+      }
+      break;
+    }
+    case StyleAppearance::RangeThumb: {
+      if (IsRangeHorizontal(aFrame)) {
+        if (aWidgetFlags) *aWidgetFlags = GTK_ORIENTATION_HORIZONTAL;
+        aGtkWidgetType = MOZ_GTK_SCALE_THUMB_HORIZONTAL;
+      } else {
+        if (aWidgetFlags) *aWidgetFlags = GTK_ORIENTATION_VERTICAL;
+        aGtkWidgetType = MOZ_GTK_SCALE_THUMB_VERTICAL;
+      }
+      break;
+    }
+    case StyleAppearance::Separator:
+      aGtkWidgetType = MOZ_GTK_TOOLBAR_SEPARATOR;
+      break;
+    case StyleAppearance::Toolbargripper:
+      aGtkWidgetType = MOZ_GTK_GRIPPER;
+      break;
+    case StyleAppearance::Resizer:
+      aGtkWidgetType = MOZ_GTK_RESIZER;
+      break;
+    case StyleAppearance::NumberInput:
+    case StyleAppearance::Textfield:
+      aGtkWidgetType = MOZ_GTK_ENTRY;
+      break;
+    case StyleAppearance::Textarea:
+      aGtkWidgetType = MOZ_GTK_TEXT_VIEW;
+      break;
+    case StyleAppearance::Listbox:
+    case StyleAppearance::Treeview:
+      aGtkWidgetType = MOZ_GTK_TREEVIEW;
+      break;
+    case StyleAppearance::Treeheadercell:
+      if (aWidgetFlags) {
+        // In this case, the flag denotes whether the header is the sorted one
+        // or not
+        if (GetTreeSortDirection(aFrame) == eTreeSortDirection_Natural)
+          *aWidgetFlags = false;
+        else
+          *aWidgetFlags = true;
+      }
+      aGtkWidgetType = MOZ_GTK_TREE_HEADER_CELL;
+      break;
+    case StyleAppearance::Treeheadersortarrow:
+      if (aWidgetFlags) {
+        switch (GetTreeSortDirection(aFrame)) {
+          case eTreeSortDirection_Ascending:
+            *aWidgetFlags = GTK_ARROW_DOWN;
+            break;
+          case eTreeSortDirection_Descending:
+            *aWidgetFlags = GTK_ARROW_UP;
+            break;
+          case eTreeSortDirection_Natural:
+          default:
+            /* This prevents the treecolums from getting smaller
+             * and wider when switching sort direction off and on
+             * */
+            *aWidgetFlags = GTK_ARROW_NONE;
+            break;
+        }
+      }
+      aGtkWidgetType = MOZ_GTK_TREE_HEADER_SORTARROW;
+      break;
+    case StyleAppearance::Treetwisty:
+      aGtkWidgetType = MOZ_GTK_TREEVIEW_EXPANDER;
+      if (aWidgetFlags) *aWidgetFlags = GTK_EXPANDER_COLLAPSED;
+      break;
+    case StyleAppearance::Treetwistyopen:
+      aGtkWidgetType = MOZ_GTK_TREEVIEW_EXPANDER;
+      if (aWidgetFlags) *aWidgetFlags = GTK_EXPANDER_EXPANDED;
+      break;
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::Menulist:
+      aGtkWidgetType = MOZ_GTK_DROPDOWN;
+      if (aWidgetFlags)
+        *aWidgetFlags =
+            IsFrameContentNodeInNamespace(aFrame, kNameSpaceID_XHTML);
+      break;
+    case StyleAppearance::MenulistText:
+      return false;  // nothing to do, but prevents the bg from being drawn
+    case StyleAppearance::MozMenulistArrowButton:
+      aGtkWidgetType = MOZ_GTK_DROPDOWN_ARROW;
+      break;
+    case StyleAppearance::ToolbarbuttonDropdown:
+    case StyleAppearance::ButtonArrowDown:
+    case StyleAppearance::ButtonArrowUp:
+    case StyleAppearance::ButtonArrowNext:
+    case StyleAppearance::ButtonArrowPrevious:
+      aGtkWidgetType = MOZ_GTK_TOOLBARBUTTON_ARROW;
+      if (aWidgetFlags) {
+        *aWidgetFlags = GTK_ARROW_DOWN;
+
+        if (aAppearance == StyleAppearance::ButtonArrowUp)
+          *aWidgetFlags = GTK_ARROW_UP;
+        else if (aAppearance == StyleAppearance::ButtonArrowNext)
+          *aWidgetFlags = GTK_ARROW_RIGHT;
+        else if (aAppearance == StyleAppearance::ButtonArrowPrevious)
+          *aWidgetFlags = GTK_ARROW_LEFT;
+      }
+      break;
+    case StyleAppearance::CheckboxContainer:
+      aGtkWidgetType = MOZ_GTK_CHECKBUTTON_CONTAINER;
+      break;
+    case StyleAppearance::RadioContainer:
+      aGtkWidgetType = MOZ_GTK_RADIOBUTTON_CONTAINER;
+      break;
+    case StyleAppearance::CheckboxLabel:
+      aGtkWidgetType = MOZ_GTK_CHECKBUTTON_LABEL;
+      break;
+    case StyleAppearance::RadioLabel:
+      aGtkWidgetType = MOZ_GTK_RADIOBUTTON_LABEL;
+      break;
+    case StyleAppearance::Toolbar:
+      aGtkWidgetType = MOZ_GTK_TOOLBAR;
+      break;
+    case StyleAppearance::Tooltip:
+      aGtkWidgetType = MOZ_GTK_TOOLTIP;
+      break;
+    case StyleAppearance::Statusbarpanel:
+    case StyleAppearance::Resizerpanel:
+      aGtkWidgetType = MOZ_GTK_FRAME;
+      break;
+    case StyleAppearance::ProgressBar:
+      aGtkWidgetType = MOZ_GTK_PROGRESSBAR;
+      break;
+    case StyleAppearance::Progresschunk: {
+      nsIFrame* stateFrame = aFrame->GetParent();
+      ElementState elementState = GetContentState(stateFrame, aAppearance);
+
+      aGtkWidgetType = elementState.HasState(ElementState::INDETERMINATE)
+                           ? IsVerticalProgress(stateFrame)
+                                 ? MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE
+                                 : MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE
+                           : MOZ_GTK_PROGRESS_CHUNK;
+    } break;
+    case StyleAppearance::TabScrollArrowBack:
+    case StyleAppearance::TabScrollArrowForward:
+      if (aWidgetFlags)
+        *aWidgetFlags = aAppearance == StyleAppearance::TabScrollArrowBack
+                            ? GTK_ARROW_LEFT
+                            : GTK_ARROW_RIGHT;
+      aGtkWidgetType = MOZ_GTK_TAB_SCROLLARROW;
+      break;
+    case StyleAppearance::Tabpanels:
+      aGtkWidgetType = MOZ_GTK_TABPANELS;
+      break;
+    case StyleAppearance::Tab: {
+      if (IsBottomTab(aFrame)) {
+        aGtkWidgetType = MOZ_GTK_TAB_BOTTOM;
+      } else {
+        aGtkWidgetType = MOZ_GTK_TAB_TOP;
+      }
+
+      if (aWidgetFlags) {
+        /* First bits will be used to store max(0,-bmargin) where bmargin
+         * is the bottom margin of the tab in pixels  (resp. top margin,
+         * for bottom tabs). */
+        *aWidgetFlags = GetTabMarginPixels(aFrame);
+
+        if (IsSelectedTab(aFrame)) *aWidgetFlags |= MOZ_GTK_TAB_SELECTED;
+
+        if (IsFirstTab(aFrame)) *aWidgetFlags |= MOZ_GTK_TAB_FIRST;
+      }
+    } break;
+    case StyleAppearance::Splitter:
+      if (IsHorizontal(aFrame))
+        aGtkWidgetType = MOZ_GTK_SPLITTER_VERTICAL;
+      else
+        aGtkWidgetType = MOZ_GTK_SPLITTER_HORIZONTAL;
+      break;
+    case StyleAppearance::Menubar:
+      aGtkWidgetType = MOZ_GTK_MENUBAR;
+      break;
+    case StyleAppearance::Menuitem: {
+      auto* item = dom::XULButtonElement::FromNode(aFrame->GetContent());
+      if (item && item->IsOnMenuBar()) {
+        aGtkWidgetType = MOZ_GTK_MENUBARITEM;
+        break;
+      }
+    }
+      aGtkWidgetType = MOZ_GTK_MENUITEM;
+      break;
+    case StyleAppearance::Menuseparator:
+      aGtkWidgetType = MOZ_GTK_MENUSEPARATOR;
+      break;
+    case StyleAppearance::Menuarrow:
+      aGtkWidgetType = MOZ_GTK_MENUARROW;
+      break;
+    case StyleAppearance::Checkmenuitem:
+      aGtkWidgetType = MOZ_GTK_CHECKMENUITEM;
+      break;
+    case StyleAppearance::Radiomenuitem:
+      aGtkWidgetType = MOZ_GTK_RADIOMENUITEM;
+      break;
+    case StyleAppearance::MozWindowTitlebar:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR;
+      break;
+    case StyleAppearance::MozWindowTitlebarMaximized:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR_MAXIMIZED;
+      break;
+    case StyleAppearance::MozWindowButtonBox:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR_BUTTON_BOX;
+      break;
+    case StyleAppearance::MozWindowButtonClose:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR_BUTTON_CLOSE;
+      break;
+    case StyleAppearance::MozWindowButtonMinimize:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE;
+      break;
+    case StyleAppearance::MozWindowButtonMaximize:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE;
+      break;
+    case StyleAppearance::MozWindowButtonRestore:
+      aGtkWidgetType = MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE;
+      break;
+    default:
+      return false;
+  }
+
+  return true;
+}
+
+class SystemCairoClipper : public ClipExporter {
+ public:
+  explicit SystemCairoClipper(cairo_t* aContext, gint aScaleFactor = 1)
+      : mContext(aContext), mScaleFactor(aScaleFactor) {}
+
+  void BeginClip(const Matrix& aTransform) override {
+    cairo_matrix_t mat;
+    GfxMatrixToCairoMatrix(aTransform, mat);
+    // We also need to remove the scale factor effect from the matrix
+    mat.y0 = mat.y0 / mScaleFactor;
+    mat.x0 = mat.x0 / mScaleFactor;
+    cairo_set_matrix(mContext, &mat);
+
+    cairo_new_path(mContext);
+  }
+
+  void MoveTo(const Point& aPoint) override {
+    cairo_move_to(mContext, aPoint.x / mScaleFactor, aPoint.y / mScaleFactor);
+    mBeginPoint = aPoint;
+    mCurrentPoint = aPoint;
+  }
+
+  void LineTo(const Point& aPoint) override {
+    cairo_line_to(mContext, aPoint.x / mScaleFactor, aPoint.y / mScaleFactor);
+    mCurrentPoint = aPoint;
+  }
+
+  void BezierTo(const Point& aCP1, const Point& aCP2,
+                const Point& aCP3) override {
+    cairo_curve_to(mContext, aCP1.x / mScaleFactor, aCP1.y / mScaleFactor,
+                   aCP2.x / mScaleFactor, aCP2.y / mScaleFactor,
+                   aCP3.x / mScaleFactor, aCP3.y / mScaleFactor);
+    mCurrentPoint = aCP3;
+  }
+
+  void QuadraticBezierTo(const Point& aCP1, const Point& aCP2) override {
+    Point CP0 = CurrentPoint();
+    Point CP1 = (CP0 + aCP1 * 2.0) / 3.0;
+    Point CP2 = (aCP2 + aCP1 * 2.0) / 3.0;
+    Point CP3 = aCP2;
+    cairo_curve_to(mContext, CP1.x / mScaleFactor, CP1.y / mScaleFactor,
+                   CP2.x / mScaleFactor, CP2.y / mScaleFactor,
+                   CP3.x / mScaleFactor, CP3.y / mScaleFactor);
+    mCurrentPoint = aCP2;
+  }
+
+  void Arc(const Point& aOrigin, float aRadius, float aStartAngle,
+           float aEndAngle, bool aAntiClockwise) override {
+    ArcToBezier(this, aOrigin, Size(aRadius, aRadius), aStartAngle, aEndAngle,
+                aAntiClockwise);
+  }
+
+  void Close() override {
+    cairo_close_path(mContext);
+    mCurrentPoint = mBeginPoint;
+  }
+
+  void EndClip() override { cairo_clip(mContext); }
+
+ private:
+  cairo_t* mContext;
+  gint mScaleFactor;
+};
+
+static void DrawThemeWithCairo(gfxContext* aContext, DrawTarget* aDrawTarget,
+                               GtkWidgetState aState,
+                               WidgetNodeType aGTKWidgetType, gint aFlags,
+                               GtkTextDirection aDirection, gint aScaleFactor,
+                               bool aSnapped, const Point& aDrawOrigin,
+                               const nsIntSize& aDrawSize,
+                               GdkRectangle& aGDKRect,
+                               nsITheme::Transparency aTransparency) {
+  static auto sCairoSurfaceSetDeviceScalePtr =
+      (void (*)(cairo_surface_t*, double, double))dlsym(
+          RTLD_DEFAULT, "cairo_surface_set_device_scale");
+  const bool useHiDPIWidgets =
+      aScaleFactor != 1 && sCairoSurfaceSetDeviceScalePtr;
+
+  Point drawOffsetScaled;
+  Point drawOffsetOriginal;
+  Matrix transform;
+  if (!aSnapped) {
+    // If we are not snapped, we depend on the DT for translation.
+    drawOffsetOriginal = aDrawOrigin;
+    drawOffsetScaled = useHiDPIWidgets ? drawOffsetOriginal / aScaleFactor
+                                       : drawOffsetOriginal;
+    transform = aDrawTarget->GetTransform().PreTranslate(drawOffsetScaled);
+  } else {
+    // Otherwise, we only need to take the device offset into account.
+    drawOffsetOriginal = aDrawOrigin - aContext->GetDeviceOffset();
+    drawOffsetScaled = useHiDPIWidgets ? drawOffsetOriginal / aScaleFactor
+                                       : drawOffsetOriginal;
+    transform = Matrix::Translation(drawOffsetScaled);
+  }
+
+  if (!useHiDPIWidgets && aScaleFactor != 1) {
+    transform.PreScale(aScaleFactor, aScaleFactor);
+  }
+
+  cairo_matrix_t mat;
+  GfxMatrixToCairoMatrix(transform, mat);
+
+  nsIntSize clipSize((aDrawSize.width + aScaleFactor - 1) / aScaleFactor,
+                     (aDrawSize.height + aScaleFactor - 1) / aScaleFactor);
+
+  // A direct Cairo draw target is not available, so we need to create a
+  // temporary one.
+#if defined(MOZ_X11) && defined(CAIRO_HAS_XLIB_SURFACE)
+  if (GdkIsX11Display()) {
+    // If using a Cairo xlib surface, then try to reuse it.
+    BorrowedXlibDrawable borrow(aDrawTarget);
+    if (borrow.GetDrawable()) {
+      nsIntSize size = borrow.GetSize();
+      cairo_surface_t* surf = cairo_xlib_surface_create(
+          borrow.GetDisplay(), borrow.GetDrawable(), borrow.GetVisual(),
+          size.width, size.height);
+      if (!NS_WARN_IF(!surf)) {
+        Point offset = borrow.GetOffset();
+        if (offset != Point()) {
+          cairo_surface_set_device_offset(surf, offset.x, offset.y);
+        }
+        cairo_t* cr = cairo_create(surf);
+        if (!NS_WARN_IF(!cr)) {
+          RefPtr<SystemCairoClipper> clipper = new SystemCairoClipper(cr);
+          aContext->ExportClip(*clipper);
+
+          cairo_set_matrix(cr, &mat);
+
+          cairo_new_path(cr);
+          cairo_rectangle(cr, 0, 0, clipSize.width, clipSize.height);
+          cairo_clip(cr);
+
+          moz_gtk_widget_paint(aGTKWidgetType, cr, &aGDKRect, &aState, aFlags,
+                               aDirection);
+
+          cairo_destroy(cr);
+        }
+        cairo_surface_destroy(surf);
+      }
+      borrow.Finish();
+      return;
+    }
+  }
+#endif
+
+  // Check if the widget requires complex masking that must be composited.
+  // Try to directly write to the draw target's pixels if possible.
+  uint8_t* data;
+  nsIntSize size;
+  int32_t stride;
+  SurfaceFormat format;
+  IntPoint origin;
+  if (aDrawTarget->LockBits(&data, &size, &stride, &format, &origin)) {
+    // Create a Cairo image surface context the device rectangle.
+    cairo_surface_t* surf = cairo_image_surface_create_for_data(
+        data, GfxFormatToCairoFormat(format), size.width, size.height, stride);
+    if (!NS_WARN_IF(!surf)) {
+      if (useHiDPIWidgets) {
+        sCairoSurfaceSetDeviceScalePtr(surf, aScaleFactor, aScaleFactor);
+      }
+      if (origin != IntPoint()) {
+        cairo_surface_set_device_offset(surf, -origin.x, -origin.y);
+      }
+      cairo_t* cr = cairo_create(surf);
+      if (!NS_WARN_IF(!cr)) {
+        RefPtr<SystemCairoClipper> clipper =
+            new SystemCairoClipper(cr, useHiDPIWidgets ? aScaleFactor : 1);
+        aContext->ExportClip(*clipper);
+
+        cairo_set_matrix(cr, &mat);
+
+        cairo_new_path(cr);
+        cairo_rectangle(cr, 0, 0, clipSize.width, clipSize.height);
+        cairo_clip(cr);
+
+        moz_gtk_widget_paint(aGTKWidgetType, cr, &aGDKRect, &aState, aFlags,
+                             aDirection);
+
+        cairo_destroy(cr);
+      }
+      cairo_surface_destroy(surf);
+    }
+    aDrawTarget->ReleaseBits(data);
+  } else {
+    // If the widget has any transparency, make sure to choose an alpha format.
+    format = aTransparency != nsITheme::eOpaque ? SurfaceFormat::B8G8R8A8
+                                                : aDrawTarget->GetFormat();
+    // Create a temporary data surface to render the widget into.
+    RefPtr<DataSourceSurface> dataSurface = Factory::CreateDataSourceSurface(
+        aDrawSize, format, aTransparency != nsITheme::eOpaque);
+    DataSourceSurface::MappedSurface map;
+    if (!NS_WARN_IF(
+            !(dataSurface &&
+              dataSurface->Map(DataSourceSurface::MapType::WRITE, &map)))) {
+      // Create a Cairo image surface wrapping the data surface.
+      cairo_surface_t* surf = cairo_image_surface_create_for_data(
+          map.mData, GfxFormatToCairoFormat(format), aDrawSize.width,
+          aDrawSize.height, map.mStride);
+      cairo_t* cr = nullptr;
+      if (!NS_WARN_IF(!surf)) {
+        cr = cairo_create(surf);
+        if (!NS_WARN_IF(!cr)) {
+          if (aScaleFactor != 1) {
+            if (useHiDPIWidgets) {
+              sCairoSurfaceSetDeviceScalePtr(surf, aScaleFactor, aScaleFactor);
+            } else {
+              cairo_scale(cr, aScaleFactor, aScaleFactor);
+            }
+          }
+
+          moz_gtk_widget_paint(aGTKWidgetType, cr, &aGDKRect, &aState, aFlags,
+                               aDirection);
+        }
+      }
+
+      // Unmap the surface before using it as a source
+      dataSurface->Unmap();
+
+      if (cr) {
+        // The widget either needs to be masked or has transparency, so use the
+        // slower drawing path.
+        aDrawTarget->DrawSurface(
+            dataSurface,
+            Rect(aSnapped ? drawOffsetOriginal -
+                                aDrawTarget->GetTransform().GetTranslation()
+                          : drawOffsetOriginal,
+                 Size(aDrawSize)),
+            Rect(0, 0, aDrawSize.width, aDrawSize.height));
+        cairo_destroy(cr);
+      }
+
+      if (surf) {
+        cairo_surface_destroy(surf);
+      }
+    }
+  }
+}
+
+bool nsNativeThemeGTK::GetExtraSizeForWidget(nsIFrame* aFrame,
+                                             StyleAppearance aAppearance,
+                                             nsIntMargin* aExtra) {
+  *aExtra = nsIntMargin(0, 0, 0, 0);
+  // Allow an extra one pixel above and below the thumb for certain
+  // GTK2 themes (Ximian Industrial, Bluecurve, Misty, at least);
+  // We modify the frame's overflow area.  See bug 297508.
+  switch (aAppearance) {
+    case StyleAppearance::Button: {
+      if (IsDefaultButton(aFrame)) {
+        // Some themes draw a default indicator outside the widget,
+        // include that in overflow
+        gint top, left, bottom, right;
+        moz_gtk_button_get_default_overflow(&top, &left, &bottom, &right);
+        aExtra->top = top;
+        aExtra->right = right;
+        aExtra->bottom = bottom;
+        aExtra->left = left;
+        break;
+      }
+      return false;
+    }
+    case StyleAppearance::FocusOutline: {
+      moz_gtk_get_focus_outline_size(&aExtra->left, &aExtra->top);
+      aExtra->right = aExtra->left;
+      aExtra->bottom = aExtra->top;
+      break;
+    }
+    case StyleAppearance::Tab: {
+      if (!IsSelectedTab(aFrame)) return false;
+
+      gint gap_height = moz_gtk_get_tab_thickness(
+          IsBottomTab(aFrame) ? MOZ_GTK_TAB_BOTTOM : MOZ_GTK_TAB_TOP);
+      if (!gap_height) return false;
+
+      int32_t extra = gap_height - GetTabMarginPixels(aFrame);
+      if (extra <= 0) return false;
+
+      if (IsBottomTab(aFrame)) {
+        aExtra->top = extra;
+      } else {
+        aExtra->bottom = extra;
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+  gint scale = GetMonitorScaleFactor(aFrame);
+  aExtra->top *= scale;
+  aExtra->right *= scale;
+  aExtra->bottom *= scale;
+  aExtra->left *= scale;
+  return true;
+}
+
+bool nsNativeThemeGTK::IsWidgetVisible(StyleAppearance aAppearance) {
+  switch (aAppearance) {
+    case StyleAppearance::MozWindowButtonBox:
+      return false;
+    default:
+      break;
+  }
+  return true;
+}
+
+NS_IMETHODIMP
+nsNativeThemeGTK::DrawWidgetBackground(gfxContext* aContext, nsIFrame* aFrame,
+                                       StyleAppearance aAppearance,
+                                       const nsRect& aRect,
+                                       const nsRect& aDirtyRect,
+                                       DrawOverflow aDrawOverflow) {
+  if (IsWidgetNonNative(aFrame, aAppearance) != NonNative::No) {
+    return Theme::DrawWidgetBackground(aContext, aFrame, aAppearance, aRect,
+                                       aDirtyRect, aDrawOverflow);
+  }
+
+  GtkWidgetState state;
+  WidgetNodeType gtkWidgetType;
+  GtkTextDirection direction = GetTextDirection(aFrame);
+  gint flags;
+
+  if (!IsWidgetVisible(aAppearance) ||
+      !GetGtkWidgetAndState(aAppearance, aFrame, gtkWidgetType, &state,
+                            &flags)) {
+    return NS_OK;
+  }
+
+  gfxContext* ctx = aContext;
+  nsPresContext* presContext = aFrame->PresContext();
+
+  gfxRect rect = presContext->AppUnitsToGfxUnits(aRect);
+  gfxRect dirtyRect = presContext->AppUnitsToGfxUnits(aDirtyRect);
+  gint scaleFactor = GetMonitorScaleFactor(aFrame);
+
+  // Align to device pixels where sensible
+  // to provide crisper and faster drawing.
+  // Don't snap if it's a non-unit scale factor. We're going to have to take
+  // slow paths then in any case.
+  // We prioritize the size when snapping in order to avoid distorting widgets
+  // that should be square, which can occur if edges are snapped independently.
+  bool snapped = ctx->UserToDevicePixelSnapped(
+      rect, gfxContext::SnapOption::PrioritizeSize);
+  if (snapped) {
+    // Leave rect in device coords but make dirtyRect consistent.
+    dirtyRect = ctx->UserToDevice(dirtyRect);
+  }
+
+  // Translate the dirty rect so that it is wrt the widget top-left.
+  dirtyRect.MoveBy(-rect.TopLeft());
+  // Round out the dirty rect to gdk pixels to ensure that gtk draws
+  // enough pixels for interpolation to device pixels.
+  dirtyRect.RoundOut();
+
+  // GTK themes can only draw an integer number of pixels
+  // (even when not snapped).
+  nsIntRect widgetRect(0, 0, NS_lround(rect.Width()), NS_lround(rect.Height()));
+  nsIntRect overflowRect(widgetRect);
+  nsIntMargin extraSize;
+  if (GetExtraSizeForWidget(aFrame, aAppearance, &extraSize)) {
+    overflowRect.Inflate(extraSize);
+  }
+
+  // This is the rectangle that will actually be drawn, in gdk pixels
+  nsIntRect drawingRect(int32_t(dirtyRect.X()), int32_t(dirtyRect.Y()),
+                        int32_t(dirtyRect.Width()),
+                        int32_t(dirtyRect.Height()));
+  if (widgetRect.IsEmpty() ||
+      !drawingRect.IntersectRect(overflowRect, drawingRect)) {
+    return NS_OK;
+  }
+
+  NS_ASSERTION(!IsWidgetTypeDisabled(mDisabledWidgetTypes, aAppearance),
+               "Trying to render an unsafe widget!");
+
+  bool safeState = IsWidgetStateSafe(mSafeWidgetStates, aAppearance, &state);
+  if (!safeState) {
+    gLastGdkError = 0;
+    gdk_error_trap_push();
+  }
+
+  Transparency transparency = GetWidgetTransparency(aFrame, aAppearance);
+
+  // gdk rectangles are wrt the drawing rect.
+  GdkRectangle gdk_rect = {
+      -drawingRect.x / scaleFactor, -drawingRect.y / scaleFactor,
+      widgetRect.width / scaleFactor, widgetRect.height / scaleFactor};
+
+  // Save actual widget scale to GtkWidgetState as we don't provide
+  // nsFrame to gtk3drawing routines.
+  state.scale = scaleFactor;
+
+  // translate everything so (0,0) is the top left of the drawingRect
+  gfxPoint origin = rect.TopLeft() + drawingRect.TopLeft();
+
+  DrawThemeWithCairo(ctx, aContext->GetDrawTarget(), state, gtkWidgetType,
+                     flags, direction, scaleFactor, snapped, ToPoint(origin),
+                     drawingRect.Size(), gdk_rect, transparency);
+
+  if (!safeState) {
+    // gdk_flush() call from expose event crashes Gtk+ on Wayland
+    // (Gnome BZ #773307)
+    if (GdkIsX11Display()) {
+      gdk_flush();
+    }
+    gLastGdkError = gdk_error_trap_pop();
+
+    if (gLastGdkError) {
+#ifdef DEBUG
+      printf(
+          "GTK theme failed for widget type %d, error was %d, state was "
+          "[active=%d,focused=%d,inHover=%d,disabled=%d]\n",
+          static_cast<int>(aAppearance), gLastGdkError, state.active,
+          state.focused, state.inHover, state.disabled);
+#endif
+      NS_WARNING("GTK theme failed; disabling unsafe widget");
+      SetWidgetTypeDisabled(mDisabledWidgetTypes, aAppearance);
+      // force refresh of the window, because the widget was not
+      // successfully drawn it must be redrawn using the default look
+      RefreshWidgetWindow(aFrame);
+    } else {
+      SetWidgetStateSafe(mSafeWidgetStates, aAppearance, &state);
+    }
+  }
+
+  // Indeterminate progress bar are animated.
+  if (gtkWidgetType == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE ||
+      gtkWidgetType == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) {
+    if (!QueueAnimatedContentForRefresh(aFrame->GetContent(), 30)) {
+      NS_WARNING("unable to animate widget!");
+    }
+  }
+
+  return NS_OK;
+}
+
+bool nsNativeThemeGTK::CreateWebRenderCommandsForWidget(
+    mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const mozilla::layers::StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager, nsIFrame* aFrame,
+    StyleAppearance aAppearance, const nsRect& aRect) {
+  if (IsWidgetNonNative(aFrame, aAppearance) != NonNative::No) {
+    return Theme::CreateWebRenderCommandsForWidget(
+        aBuilder, aResources, aSc, aManager, aFrame, aAppearance, aRect);
+  }
+  return false;
+}
+
+WidgetNodeType nsNativeThemeGTK::NativeThemeToGtkTheme(
+    StyleAppearance aAppearance, nsIFrame* aFrame) {
+  WidgetNodeType gtkWidgetType;
+  gint unusedFlags;
+
+  if (!GetGtkWidgetAndState(aAppearance, aFrame, gtkWidgetType, nullptr,
+                            &unusedFlags)) {
+    MOZ_ASSERT_UNREACHABLE("Unknown native widget to gtk widget mapping");
+    return MOZ_GTK_WINDOW;
+  }
+  return gtkWidgetType;
+}
+
+static void FixupForVerticalWritingMode(WritingMode aWritingMode,
+                                        LayoutDeviceIntMargin* aResult) {
+  if (aWritingMode.IsVertical()) {
+    bool rtl = aWritingMode.IsBidiRTL();
+    LogicalMargin logical(aWritingMode, aResult->top,
+                          rtl ? aResult->left : aResult->right, aResult->bottom,
+                          rtl ? aResult->right : aResult->left);
+    nsMargin physical = logical.GetPhysicalMargin(aWritingMode);
+    aResult->top = physical.top;
+    aResult->right = physical.right;
+    aResult->bottom = physical.bottom;
+    aResult->left = physical.left;
+  }
+}
+
+void nsNativeThemeGTK::GetCachedWidgetBorder(nsIFrame* aFrame,
+                                             StyleAppearance aAppearance,
+                                             GtkTextDirection aDirection,
+                                             LayoutDeviceIntMargin* aResult) {
+  aResult->SizeTo(0, 0, 0, 0);
+
+  WidgetNodeType gtkWidgetType;
+  gint unusedFlags;
+  if (GetGtkWidgetAndState(aAppearance, aFrame, gtkWidgetType, nullptr,
+                           &unusedFlags)) {
+    MOZ_ASSERT(0 <= gtkWidgetType && gtkWidgetType < MOZ_GTK_WIDGET_NODE_COUNT);
+    uint8_t cacheIndex = gtkWidgetType / 8;
+    uint8_t cacheBit = 1u << (gtkWidgetType % 8);
+
+    if (mBorderCacheValid[cacheIndex] & cacheBit) {
+      *aResult = mBorderCache[gtkWidgetType];
+    } else {
+      moz_gtk_get_widget_border(gtkWidgetType, &aResult->left, &aResult->top,
+                                &aResult->right, &aResult->bottom, aDirection);
+      if (gtkWidgetType != MOZ_GTK_DROPDOWN) {  // depends on aDirection
+        mBorderCacheValid[cacheIndex] |= cacheBit;
+        mBorderCache[gtkWidgetType] = *aResult;
+      }
+    }
+  }
+  FixupForVerticalWritingMode(aFrame->GetWritingMode(), aResult);
+}
+
+LayoutDeviceIntMargin nsNativeThemeGTK::GetWidgetBorder(
+    nsDeviceContext* aContext, nsIFrame* aFrame, StyleAppearance aAppearance) {
+  LayoutDeviceIntMargin result;
+  GtkTextDirection direction = GetTextDirection(aFrame);
+  switch (aAppearance) {
+    case StyleAppearance::Toolbox:
+      // gtk has no toolbox equivalent.  So, although we map toolbox to
+      // gtk's 'toolbar' for purposes of painting the widget background,
+      // we don't use the toolbar border for toolbox.
+      break;
+    case StyleAppearance::Menuitem:
+    case StyleAppearance::Checkmenuitem:
+    case StyleAppearance::Radiomenuitem:
+      // We use GetWidgetPadding for these.
+      break;
+    case StyleAppearance::Dualbutton:
+      // TOOLBAR_DUAL_BUTTON is an interesting case.  We want a border to draw
+      // around the entire button + dropdown, and also an inner border if you're
+      // over the button part.  But, we want the inner button to be right up
+      // against the edge of the outer button so that the borders overlap.
+      // To make this happen, we draw a button border for the outer button,
+      // but don't reserve any space for it.
+      break;
+    case StyleAppearance::Tab: {
+      WidgetNodeType gtkWidgetType;
+      gint flags;
+
+      if (!GetGtkWidgetAndState(aAppearance, aFrame, gtkWidgetType, nullptr,
+                                &flags)) {
+        return result;
+      }
+      moz_gtk_get_tab_border(&result.left, &result.top, &result.right,
+                             &result.bottom, direction, (GtkTabFlags)flags,
+                             gtkWidgetType);
+    } break;
+    default: {
+      GetCachedWidgetBorder(aFrame, aAppearance, direction, &result);
+    }
+  }
+
+  gint scale = GetMonitorScaleFactor(aFrame);
+  result.top *= scale;
+  result.right *= scale;
+  result.bottom *= scale;
+  result.left *= scale;
+  return result;
+}
+
+bool nsNativeThemeGTK::GetWidgetPadding(nsDeviceContext* aContext,
+                                        nsIFrame* aFrame,
+                                        StyleAppearance aAppearance,
+                                        LayoutDeviceIntMargin* aResult) {
+  switch (aAppearance) {
+    case StyleAppearance::Toolbarbutton:
+    case StyleAppearance::Tooltip:
+    case StyleAppearance::MozWindowButtonBox:
+    case StyleAppearance::MozWindowButtonClose:
+    case StyleAppearance::MozWindowButtonMinimize:
+    case StyleAppearance::MozWindowButtonMaximize:
+    case StyleAppearance::MozWindowButtonRestore:
+    case StyleAppearance::Dualbutton:
+    case StyleAppearance::TabScrollArrowBack:
+    case StyleAppearance::TabScrollArrowForward:
+    case StyleAppearance::MozMenulistArrowButton:
+    case StyleAppearance::ToolbarbuttonDropdown:
+    case StyleAppearance::ButtonArrowUp:
+    case StyleAppearance::ButtonArrowDown:
+    case StyleAppearance::ButtonArrowNext:
+    case StyleAppearance::ButtonArrowPrevious:
+    case StyleAppearance::RangeThumb:
+    // Radios and checkboxes return a fixed size in GetMinimumWidgetSize
+    // and have a meaningful baseline, so they can't have
+    // author-specified padding.
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::Radio:
+      aResult->SizeTo(0, 0, 0, 0);
+      return true;
+    case StyleAppearance::Menuitem:
+    case StyleAppearance::Checkmenuitem:
+    case StyleAppearance::Radiomenuitem: {
+      GetCachedWidgetBorder(aFrame, aAppearance, GetTextDirection(aFrame),
+                            aResult);
+
+      gint horizontal_padding = 0;
+      if (aAppearance == StyleAppearance::Menuitem)
+        moz_gtk_menuitem_get_horizontal_padding(&horizontal_padding);
+      else
+        moz_gtk_checkmenuitem_get_horizontal_padding(&horizontal_padding);
+
+      aResult->left += horizontal_padding;
+      aResult->right += horizontal_padding;
+
+      gint scale = GetMonitorScaleFactor(aFrame);
+      aResult->top *= scale;
+      aResult->right *= scale;
+      aResult->bottom *= scale;
+      aResult->left *= scale;
+
+      return true;
+    }
+    default:
+      break;
+  }
+
+  return false;
+}
+
+bool nsNativeThemeGTK::GetWidgetOverflow(nsDeviceContext* aContext,
+                                         nsIFrame* aFrame,
+                                         StyleAppearance aAppearance,
+                                         nsRect* aOverflowRect) {
+  if (IsWidgetNonNative(aFrame, aAppearance) != NonNative::No) {
+    return Theme::GetWidgetOverflow(aContext, aFrame, aAppearance,
+                                    aOverflowRect);
+  }
+
+  nsIntMargin extraSize;
+  if (!GetExtraSizeForWidget(aFrame, aAppearance, &extraSize)) {
+    return false;
+  }
+
+  int32_t p2a = aContext->AppUnitsPerDevPixel();
+  nsMargin m(NSIntPixelsToAppUnits(extraSize.top, p2a),
+             NSIntPixelsToAppUnits(extraSize.right, p2a),
+             NSIntPixelsToAppUnits(extraSize.bottom, p2a),
+             NSIntPixelsToAppUnits(extraSize.left, p2a));
+
+  aOverflowRect->Inflate(m);
+  return true;
+}
+
+auto nsNativeThemeGTK::IsWidgetNonNative(nsIFrame* aFrame,
+                                         StyleAppearance aAppearance)
+    -> NonNative {
+  if (IsWidgetScrollbarPart(aAppearance)) {
+    return NonNative::Always;
+  }
+  // We can't draw light widgets if the current GTK theme is dark or vice versa.
+  if (Theme::ThemeSupportsWidget(aFrame->PresContext(), aFrame, aAppearance) &&
+      LookAndFeel::ColorSchemeForFrame(aFrame) !=
+          LookAndFeel::ColorSchemeForChrome()) {
+    return NonNative::BecauseColorMismatch;
+  }
+  return NonNative::No;
+}
+
+LayoutDeviceIntSize nsNativeThemeGTK::GetMinimumWidgetSize(
+    nsPresContext* aPresContext, nsIFrame* aFrame,
+    StyleAppearance aAppearance) {
+  if (IsWidgetNonNative(aFrame, aAppearance) == NonNative::Always) {
+    return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance);
+  }
+
+  LayoutDeviceIntSize result;
+  switch (aAppearance) {
+    case StyleAppearance::Splitter: {
+      if (IsHorizontal(aFrame)) {
+        moz_gtk_splitter_get_metrics(GTK_ORIENTATION_HORIZONTAL, &result.width);
+      } else {
+        moz_gtk_splitter_get_metrics(GTK_ORIENTATION_VERTICAL, &result.height);
+      }
+    } break;
+    case StyleAppearance::RangeThumb: {
+      if (IsRangeHorizontal(aFrame)) {
+        moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_HORIZONTAL,
+                                       &result.width, &result.height);
+      } else {
+        moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &result.width,
+                                       &result.width);
+      }
+    } break;
+    case StyleAppearance::TabScrollArrowBack:
+    case StyleAppearance::TabScrollArrowForward: {
+      moz_gtk_get_tab_scroll_arrow_size(&result.width, &result.height);
+    } break;
+    case StyleAppearance::MozMenulistArrowButton: {
+      moz_gtk_get_combo_box_entry_button_size(&result.width, &result.height);
+    } break;
+    case StyleAppearance::Menuseparator: {
+      moz_gtk_get_menu_separator_height(&result.height);
+    } break;
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::Radio: {
+      const ToggleGTKMetrics* metrics = GetToggleMetrics(
+          aAppearance == StyleAppearance::Radio ? MOZ_GTK_RADIOBUTTON
+                                                : MOZ_GTK_CHECKBUTTON);
+      result.width = metrics->minSizeWithBorder.width;
+      result.height = metrics->minSizeWithBorder.height;
+    } break;
+    case StyleAppearance::ToolbarbuttonDropdown:
+    case StyleAppearance::ButtonArrowUp:
+    case StyleAppearance::ButtonArrowDown:
+    case StyleAppearance::ButtonArrowNext:
+    case StyleAppearance::ButtonArrowPrevious: {
+      moz_gtk_get_arrow_size(MOZ_GTK_TOOLBARBUTTON_ARROW, &result.width,
+                             &result.height);
+    } break;
+    case StyleAppearance::MozWindowButtonClose: {
+      const ToolbarButtonGTKMetrics* metrics =
+          GetToolbarButtonMetrics(MOZ_GTK_HEADER_BAR_BUTTON_CLOSE);
+      result.width = metrics->minSizeWithBorderMargin.width;
+      result.height = metrics->minSizeWithBorderMargin.height;
+      break;
+    }
+    case StyleAppearance::MozWindowButtonMinimize: {
+      const ToolbarButtonGTKMetrics* metrics =
+          GetToolbarButtonMetrics(MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE);
+      result.width = metrics->minSizeWithBorderMargin.width;
+      result.height = metrics->minSizeWithBorderMargin.height;
+      break;
+    }
+    case StyleAppearance::MozWindowButtonMaximize:
+    case StyleAppearance::MozWindowButtonRestore: {
+      const ToolbarButtonGTKMetrics* metrics =
+          GetToolbarButtonMetrics(MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE);
+      result.width = metrics->minSizeWithBorderMargin.width;
+      result.height = metrics->minSizeWithBorderMargin.height;
+      break;
+    }
+    case StyleAppearance::CheckboxContainer:
+    case StyleAppearance::RadioContainer:
+    case StyleAppearance::CheckboxLabel:
+    case StyleAppearance::RadioLabel:
+    case StyleAppearance::Button:
+    case StyleAppearance::Menulist:
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::Toolbarbutton:
+    case StyleAppearance::Treeheadercell: {
+      if (aAppearance == StyleAppearance::Menulist ||
+          aAppearance == StyleAppearance::MenulistButton) {
+        // Include the arrow size.
+        moz_gtk_get_arrow_size(MOZ_GTK_DROPDOWN, &result.width, &result.height);
+      }
+      // else the minimum size is missing consideration of container
+      // descendants; the value returned here will not be helpful, but the
+      // box model may consider border and padding with child minimum sizes.
+
+      LayoutDeviceIntMargin border;
+      GetCachedWidgetBorder(aFrame, aAppearance, GetTextDirection(aFrame),
+                            &border);
+      result.width += border.LeftRight();
+      result.height += border.TopBottom();
+    } break;
+    case StyleAppearance::NumberInput:
+    case StyleAppearance::Textfield: {
+      gint contentHeight = 0;
+      gint borderPaddingHeight = 0;
+      moz_gtk_get_entry_min_height(&contentHeight, &borderPaddingHeight);
+
+      // Scale the min content height proportionately with the font-size if it's
+      // smaller than the default one. This prevents <input type=text
+      // style="font-size: .5em"> from keeping a ridiculously large size, for
+      // example.
+      const gfxFloat fieldFontSizeInCSSPixels = [] {
+        gfxFontStyle fieldFontStyle;
+        nsAutoString unusedFontName;
+        DebugOnly<bool> result = LookAndFeel::GetFont(
+            LookAndFeel::FontID::MozField, unusedFontName, fieldFontStyle);
+        MOZ_ASSERT(result, "GTK look and feel supports the field font");
+        // NOTE: GetFont returns font sizes in CSS pixels, and we want just
+        // that.
+        return fieldFontStyle.size;
+      }();
+
+      const gfxFloat fontSize = aFrame->StyleFont()->mFont.size.ToCSSPixels();
+      if (fieldFontSizeInCSSPixels > fontSize) {
+        contentHeight =
+            std::round(contentHeight * fontSize / fieldFontSizeInCSSPixels);
+      }
+
+      gint height = contentHeight + borderPaddingHeight;
+      if (aFrame->GetWritingMode().IsVertical()) {
+        result.width = height;
+      } else {
+        result.height = height;
+      }
+    } break;
+    case StyleAppearance::Separator: {
+      moz_gtk_get_toolbar_separator_width(&result.width);
+    } break;
+    case StyleAppearance::Spinner:
+      // hard code these sizes
+      result.width = 14;
+      result.height = 26;
+      break;
+    case StyleAppearance::Treeheadersortarrow:
+    case StyleAppearance::SpinnerUpbutton:
+    case StyleAppearance::SpinnerDownbutton:
+      // hard code these sizes
+      result.width = 14;
+      result.height = 13;
+      break;
+    case StyleAppearance::Resizer:
+      // same as Windows to make our lives easier
+      result.width = result.height = 15;
+      break;
+    case StyleAppearance::Treetwisty:
+    case StyleAppearance::Treetwistyopen: {
+      gint expander_size;
+      moz_gtk_get_treeview_expander_size(&expander_size);
+      result.width = result.height = expander_size;
+    } break;
+    default:
+      break;
+  }
+
+  return result * GetMonitorScaleFactor(aFrame);
+}
+
+NS_IMETHODIMP
+nsNativeThemeGTK::WidgetStateChanged(nsIFrame* aFrame,
+                                     StyleAppearance aAppearance,
+                                     nsAtom* aAttribute, bool* aShouldRepaint,
+                                     const nsAttrValue* aOldValue) {
+  *aShouldRepaint = false;
+
+  if (IsWidgetNonNative(aFrame, aAppearance) != NonNative::No) {
+    return Theme::WidgetStateChanged(aFrame, aAppearance, aAttribute,
+                                     aShouldRepaint, aOldValue);
+  }
+
+  // Some widget types just never change state.
+  if (aAppearance == StyleAppearance::Toolbox ||
+      aAppearance == StyleAppearance::Toolbar ||
+      aAppearance == StyleAppearance::Statusbar ||
+      aAppearance == StyleAppearance::Statusbarpanel ||
+      aAppearance == StyleAppearance::Resizerpanel ||
+      aAppearance == StyleAppearance::Progresschunk ||
+      aAppearance == StyleAppearance::ProgressBar ||
+      aAppearance == StyleAppearance::Menubar ||
+      aAppearance == StyleAppearance::Tooltip ||
+      aAppearance == StyleAppearance::Menuseparator) {
+    return NS_OK;
+  }
+
+  if (aAppearance == StyleAppearance::MozWindowTitlebar ||
+      aAppearance == StyleAppearance::MozWindowTitlebarMaximized ||
+      aAppearance == StyleAppearance::MozWindowButtonClose ||
+      aAppearance == StyleAppearance::MozWindowButtonMinimize ||
+      aAppearance == StyleAppearance::MozWindowButtonMaximize ||
+      aAppearance == StyleAppearance::MozWindowButtonRestore) {
+    *aShouldRepaint = true;
+    return NS_OK;
+  }
+
+  // XXXdwh Not sure what can really be done here.  Can at least guess for
+  // specific widgets that they're highly unlikely to have certain states.
+  // For example, a toolbar doesn't care about any states.
+  if (!aAttribute) {
+    // Hover/focus/active changed.  Always repaint.
+    *aShouldRepaint = true;
+    return NS_OK;
+  }
+
+  // Check the attribute to see if it's relevant.
+  // disabled, checked, dlgtype, default, etc.
+  *aShouldRepaint = false;
+  if (aAttribute == nsGkAtoms::disabled || aAttribute == nsGkAtoms::checked ||
+      aAttribute == nsGkAtoms::selected ||
+      aAttribute == nsGkAtoms::visuallyselected ||
+      aAttribute == nsGkAtoms::focused || aAttribute == nsGkAtoms::readonly ||
+      aAttribute == nsGkAtoms::_default ||
+      aAttribute == nsGkAtoms::menuactive || aAttribute == nsGkAtoms::open ||
+      aAttribute == nsGkAtoms::parentfocused) {
+    *aShouldRepaint = true;
+    return NS_OK;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNativeThemeGTK::ThemeChanged() {
+  memset(mDisabledWidgetTypes, 0, sizeof(mDisabledWidgetTypes));
+  memset(mSafeWidgetStates, 0, sizeof(mSafeWidgetStates));
+  memset(mBorderCacheValid, 0, sizeof(mBorderCacheValid));
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(bool)
+nsNativeThemeGTK::ThemeSupportsWidget(nsPresContext* aPresContext,
+                                      nsIFrame* aFrame,
+                                      StyleAppearance aAppearance) {
+  if (IsWidgetTypeDisabled(mDisabledWidgetTypes, aAppearance)) {
+    return false;
+  }
+
+  if (IsWidgetNonNative(aFrame, aAppearance) == NonNative::Always) {
+    return Theme::ThemeSupportsWidget(aPresContext, aFrame, aAppearance);
+  }
+
+  switch (aAppearance) {
+    // Combobox dropdowns don't support native theming in vertical mode.
+    case StyleAppearance::Menulist:
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::MenulistText:
+      if (aFrame && aFrame->GetWritingMode().IsVertical()) {
+        return false;
+      }
+      [[fallthrough]];
+
+    case StyleAppearance::Button:
+    case StyleAppearance::Radio:
+    case StyleAppearance::Checkbox:
+    case StyleAppearance::Toolbox:  // N/A
+    case StyleAppearance::Toolbar:
+    case StyleAppearance::Toolbarbutton:
+    case StyleAppearance::Dualbutton:  // so we can override the border with 0
+    case StyleAppearance::ToolbarbuttonDropdown:
+    case StyleAppearance::ButtonArrowUp:
+    case StyleAppearance::ButtonArrowDown:
+    case StyleAppearance::ButtonArrowNext:
+    case StyleAppearance::ButtonArrowPrevious:
+    case StyleAppearance::Separator:
+    case StyleAppearance::Toolbargripper:
+    case StyleAppearance::Statusbar:
+    case StyleAppearance::Statusbarpanel:
+    case StyleAppearance::Resizerpanel:
+    case StyleAppearance::Resizer:
+    case StyleAppearance::Listbox:
+    case StyleAppearance::Treeview:
+      // case StyleAppearance::Treeitem:
+    case StyleAppearance::Treetwisty:
+      // case StyleAppearance::Treeline:
+      // case StyleAppearance::Treeheader:
+    case StyleAppearance::Treeheadercell:
+    case StyleAppearance::Treeheadersortarrow:
+    case StyleAppearance::Treetwistyopen:
+    case StyleAppearance::ProgressBar:
+    case StyleAppearance::Progresschunk:
+    case StyleAppearance::Tab:
+    // case StyleAppearance::Tabpanel:
+    case StyleAppearance::Tabpanels:
+    case StyleAppearance::TabScrollArrowBack:
+    case StyleAppearance::TabScrollArrowForward:
+    case StyleAppearance::Tooltip:
+    case StyleAppearance::Spinner:
+    case StyleAppearance::SpinnerUpbutton:
+    case StyleAppearance::SpinnerDownbutton:
+    case StyleAppearance::SpinnerTextfield:
+    case StyleAppearance::NumberInput:
+    case StyleAppearance::Textfield:
+    case StyleAppearance::Textarea:
+    case StyleAppearance::Range:
+    case StyleAppearance::RangeThumb:
+    case StyleAppearance::CheckboxContainer:
+    case StyleAppearance::RadioContainer:
+    case StyleAppearance::CheckboxLabel:
+    case StyleAppearance::RadioLabel:
+    case StyleAppearance::Menubar:
+    case StyleAppearance::Menuitem:
+    case StyleAppearance::Menuarrow:
+    case StyleAppearance::Menuseparator:
+    case StyleAppearance::Checkmenuitem:
+    case StyleAppearance::Radiomenuitem:
+    case StyleAppearance::Splitter:
+    case StyleAppearance::MozWindowButtonBox:
+    case StyleAppearance::MozWindowButtonClose:
+    case StyleAppearance::MozWindowButtonMinimize:
+    case StyleAppearance::MozWindowButtonMaximize:
+    case StyleAppearance::MozWindowButtonRestore:
+    case StyleAppearance::MozWindowTitlebar:
+    case StyleAppearance::MozWindowTitlebarMaximized:
+      return !IsWidgetStyled(aPresContext, aFrame, aAppearance);
+
+    case StyleAppearance::MozMenulistArrowButton:
+      if (aFrame && aFrame->GetWritingMode().IsVertical()) {
+        return false;
+      }
+      // "Native" dropdown buttons cause padding and margin problems, but only
+      // in HTML so allow them in XUL.
+      return (!aFrame ||
+              IsFrameContentNodeInNamespace(aFrame, kNameSpaceID_XUL)) &&
+             !IsWidgetStyled(aPresContext, aFrame, aAppearance);
+
+    case StyleAppearance::FocusOutline:
+      return true;
+    default:
+      break;
+  }
+
+  return false;
+}
+
+NS_IMETHODIMP_(bool)
+nsNativeThemeGTK::WidgetIsContainer(StyleAppearance aAppearance) {
+  // XXXdwh At some point flesh all of this out.
+  if (aAppearance == StyleAppearance::MozMenulistArrowButton ||
+      aAppearance == StyleAppearance::Radio ||
+      aAppearance == StyleAppearance::RangeThumb ||
+      aAppearance == StyleAppearance::Checkbox ||
+      aAppearance == StyleAppearance::TabScrollArrowBack ||
+      aAppearance == StyleAppearance::TabScrollArrowForward ||
+      aAppearance == StyleAppearance::ButtonArrowUp ||
+      aAppearance == StyleAppearance::ButtonArrowDown ||
+      aAppearance == StyleAppearance::ButtonArrowNext ||
+      aAppearance == StyleAppearance::ButtonArrowPrevious)
+    return false;
+  return true;
+}
+
+bool nsNativeThemeGTK::ThemeDrawsFocusForWidget(nsIFrame* aFrame,
+                                                StyleAppearance aAppearance) {
+  if (IsWidgetNonNative(aFrame, aAppearance) != NonNative::No) {
+    return Theme::ThemeDrawsFocusForWidget(aFrame, aAppearance);
+  }
+  switch (aAppearance) {
+    case StyleAppearance::Button:
+    case StyleAppearance::Menulist:
+    case StyleAppearance::MenulistButton:
+    case StyleAppearance::Textarea:
+    case StyleAppearance::Textfield:
+    case StyleAppearance::Treeheadercell:
+    case StyleAppearance::NumberInput:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool nsNativeThemeGTK::ThemeNeedsComboboxDropmarker() { return false; }
+
+nsITheme::Transparency nsNativeThemeGTK::GetWidgetTransparency(
+    nsIFrame* aFrame, StyleAppearance aAppearance) {
+  if (IsWidgetNonNative(aFrame, aAppearance) != NonNative::No) {
+    return Theme::GetWidgetTransparency(aFrame, aAppearance);
+  }
+
+  switch (aAppearance) {
+    // Tooltips use gtk_paint_flat_box() on Gtk2
+    // but are shaped on Gtk3
+    case StyleAppearance::Tooltip:
+      return eTransparent;
+    default:
+      return eUnknownTransparency;
+  }
+}
+
+already_AddRefed<Theme> do_CreateNativeThemeDoNotUseDirectly() {
+  if (gfxPlatform::IsHeadless()) {
+    return do_AddRef(new Theme(Theme::ScrollbarStyle()));
+  }
+  return do_AddRef(new nsNativeThemeGTK());
+}
diff --git a/widget/gtk/nsNativeThemeGTK.h b/widget/gtk/nsNativeThemeGTK.h
new file mode 100644
index 0000000000..677492a16b
--- /dev/null
+++ b/widget/gtk/nsNativeThemeGTK.h
@@ -0,0 +1,119 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _GTK_NSNATIVETHEMEGTK_H_
+#define _GTK_NSNATIVETHEMEGTK_H_
+
+#include "nsITheme.h"
+#include "nsCOMPtr.h"
+#include "nsAtom.h"
+#include "Theme.h"
+
+#include <gtk/gtk.h>
+#include "gtkdrawing.h"
+
+class nsNativeThemeGTK final : public mozilla::widget::Theme {
+  using Theme = mozilla::widget::Theme;
+
+ public:
+  // The nsITheme interface.
+  NS_IMETHOD DrawWidgetBackground(gfxContext* aContext, nsIFrame* aFrame,
+                                  StyleAppearance aAppearance,
+                                  const nsRect& aRect, const nsRect& aDirtyRect,
+                                  DrawOverflow) override;
+
+  bool CreateWebRenderCommandsForWidget(
+      mozilla::wr::DisplayListBuilder& aBuilder,
+      mozilla::wr::IpcResourceUpdateQueue& aResources,
+      const mozilla::layers::StackingContextHelper& aSc,
+      mozilla::layers::RenderRootStateManager* aManager, nsIFrame*,
+      StyleAppearance, const nsRect& aRect) override;
+
+  [[nodiscard]] LayoutDeviceIntMargin GetWidgetBorder(
+      nsDeviceContext* aContext, nsIFrame* aFrame,
+      StyleAppearance aAppearance) override;
+
+  bool GetWidgetPadding(nsDeviceContext* aContext, nsIFrame* aFrame,
+                        StyleAppearance aAppearance,
+                        LayoutDeviceIntMargin* aResult) override;
+
+  bool GetWidgetOverflow(nsDeviceContext* aContext, nsIFrame* aFrame,
+                         StyleAppearance aAppearance,
+                         nsRect* aOverflowRect) override;
+
+  // Whether we draw a non-native widget.
+  //
+  // We always draw scrollbars as non-native so that all of Firefox has
+  // consistent scrollbar styles both in chrome and content (plus, the
+  // non-native scrollbars support scrollbar-width, auto-darkening...).
+  //
+  // We draw other widgets as non-native when their color-scheme doesn't match
+  // the current GTK theme's color-scheme. We do that because frequently
+  // switching GTK themes at runtime is prohibitively expensive. In that case
+  // (`BecauseColorMismatch`) we don't call into the non-native theme for sizing
+  // information (GetWidgetPadding/Border and GetMinimumWidgetSize), to avoid
+  // subtle sizing changes. The non-native theme can basically draw at any size,
+  // so we prefer to have consistent sizing information.
+  enum class NonNative { No, Always, BecauseColorMismatch };
+  NonNative IsWidgetNonNative(nsIFrame*, StyleAppearance);
+
+  mozilla::LayoutDeviceIntSize GetMinimumWidgetSize(
+      nsPresContext* aPresContext, nsIFrame* aFrame,
+      StyleAppearance aAppearance) override;
+
+  NS_IMETHOD WidgetStateChanged(nsIFrame* aFrame, StyleAppearance aAppearance,
+                                nsAtom* aAttribute, bool* aShouldRepaint,
+                                const nsAttrValue* aOldValue) override;
+
+  NS_IMETHOD ThemeChanged() override;
+
+  NS_IMETHOD_(bool)
+  ThemeSupportsWidget(nsPresContext* aPresContext, nsIFrame* aFrame,
+                      StyleAppearance aAppearance) override;
+
+  NS_IMETHOD_(bool) WidgetIsContainer(StyleAppearance aAppearance) override;
+
+  bool ThemeDrawsFocusForWidget(nsIFrame*, StyleAppearance) override;
+
+  bool ThemeNeedsComboboxDropmarker() override;
+  Transparency GetWidgetTransparency(nsIFrame*, StyleAppearance) override;
+
+  nsNativeThemeGTK();
+
+ protected:
+  virtual ~nsNativeThemeGTK();
+
+ private:
+  GtkTextDirection GetTextDirection(nsIFrame* aFrame);
+  gint GetTabMarginPixels(nsIFrame* aFrame);
+  bool GetGtkWidgetAndState(StyleAppearance aAppearance, nsIFrame* aFrame,
+                            WidgetNodeType& aGtkWidgetType,
+                            GtkWidgetState* aState, gint* aWidgetFlags);
+  bool GetExtraSizeForWidget(nsIFrame* aFrame, StyleAppearance aAppearance,
+                             nsIntMargin* aExtra);
+  bool IsWidgetVisible(StyleAppearance aAppearance);
+
+  void RefreshWidgetWindow(nsIFrame* aFrame);
+  WidgetNodeType NativeThemeToGtkTheme(StyleAppearance aAppearance,
+                                       nsIFrame* aFrame);
+
+  uint8_t mDisabledWidgetTypes
+      [(static_cast<size_t>(mozilla::StyleAppearance::Count) + 7) / 8];
+  uint8_t
+      mSafeWidgetStates[static_cast<size_t>(mozilla::StyleAppearance::Count) *
+                        4];  // 32 bits per widget
+  static const char* sDisabledEngines[];
+
+  // Because moz_gtk_get_widget_border can be slow, we cache its results
+  // by widget type.  Each bit in mBorderCacheValid says whether the
+  // corresponding entry in mBorderCache is valid.
+  void GetCachedWidgetBorder(nsIFrame* aFrame, StyleAppearance aAppearance,
+                             GtkTextDirection aDirection,
+                             LayoutDeviceIntMargin* aResult);
+  uint8_t mBorderCacheValid[(MOZ_GTK_WIDGET_NODE_COUNT + 7) / 8];
+  LayoutDeviceIntMargin mBorderCache[MOZ_GTK_WIDGET_NODE_COUNT];
+};
+
+#endif
diff --git a/widget/gtk/nsPrintDialogGTK.cpp b/widget/gtk/nsPrintDialogGTK.cpp
new file mode 100644
index 0000000000..3885a94c24
--- /dev/null
+++ b/widget/gtk/nsPrintDialogGTK.cpp
@@ -0,0 +1,621 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <gtk/gtk.h>
+#include <gtk/gtkunixprint.h>
+#include <stdlib.h>
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Services.h"
+
+#include "MozContainer.h"
+#include "nsIPrintSettings.h"
+#include "nsIWidget.h"
+#include "nsPrintDialogGTK.h"
+#include "nsPrintSettingsGTK.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsIStringBundle.h"
+#include "nsIPrintSettingsService.h"
+#include "nsPIDOMWindow.h"
+#include "nsPrintfCString.h"
+#include "nsIGIOService.h"
+#include "nsServiceManagerUtils.h"
+#include "WidgetUtils.h"
+#include "WidgetUtilsGtk.h"
+#include "nsIObserverService.h"
+
+// for gdk_x11_window_get_xid
+#include <gdk/gdk.h>
+#ifdef MOZ_X11
+#  include <gdk/gdkx.h>
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <gio/gunixfdlist.h>
+
+// for dlsym
+#include <dlfcn.h>
+#include "MainThreadUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::widget;
+
+static const char header_footer_tags[][4] = {"", "&T", "&U", "&D", "&P", "&PT"};
+
+#define CUSTOM_VALUE_INDEX gint(ArrayLength(header_footer_tags))
+
+static GtkWindow* get_gtk_window_for_nsiwidget(nsIWidget* widget) {
+  return GTK_WINDOW(widget->GetNativeData(NS_NATIVE_SHELLWIDGET));
+}
+
+static void ShowCustomDialog(GtkComboBox* changed_box, gpointer user_data) {
+  if (gtk_combo_box_get_active(changed_box) != CUSTOM_VALUE_INDEX) {
+    g_object_set_data(G_OBJECT(changed_box), "previous-active",
+                      GINT_TO_POINTER(gtk_combo_box_get_active(changed_box)));
+    return;
+  }
+
+  GtkWindow* printDialog = GTK_WINDOW(user_data);
+  nsCOMPtr<nsIStringBundleService> bundleSvc =
+      do_GetService(NS_STRINGBUNDLE_CONTRACTID);
+
+  nsCOMPtr<nsIStringBundle> printBundle;
+  bundleSvc->CreateBundle("chrome://global/locale/printdialog.properties",
+                          getter_AddRefs(printBundle));
+  nsAutoString intlString;
+
+  printBundle->GetStringFromName("headerFooterCustom", intlString);
+  GtkWidget* prompt_dialog = gtk_dialog_new_with_buttons(
+      NS_ConvertUTF16toUTF8(intlString).get(), printDialog,
+      (GtkDialogFlags)(GTK_DIALOG_MODAL), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
+      GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, nullptr);
+  gtk_dialog_set_default_response(GTK_DIALOG(prompt_dialog),
+                                  GTK_RESPONSE_ACCEPT);
+  gtk_dialog_set_alternative_button_order(
+      GTK_DIALOG(prompt_dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_REJECT, -1);
+
+  printBundle->GetStringFromName("customHeaderFooterPrompt", intlString);
+  GtkWidget* custom_label =
+      gtk_label_new(NS_ConvertUTF16toUTF8(intlString).get());
+  GtkWidget* custom_entry = gtk_entry_new();
+  GtkWidget* question_icon =
+      gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
+
+  // To be convenient, prefill the textbox with the existing value, if any, and
+  // select it all so they can easily both edit it and type in a new one.
+  const char* current_text =
+      (const char*)g_object_get_data(G_OBJECT(changed_box), "custom-text");
+  if (current_text) {
+    gtk_entry_set_text(GTK_ENTRY(custom_entry), current_text);
+    gtk_editable_select_region(GTK_EDITABLE(custom_entry), 0, -1);
+  }
+  gtk_entry_set_activates_default(GTK_ENTRY(custom_entry), TRUE);
+
+  GtkWidget* custom_vbox = gtk_vbox_new(TRUE, 2);
+  gtk_box_pack_start(GTK_BOX(custom_vbox), custom_label, FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(custom_vbox), custom_entry, FALSE, FALSE,
+                     5);  // Make entry 5px underneath label
+  GtkWidget* custom_hbox = gtk_hbox_new(FALSE, 2);
+  gtk_box_pack_start(GTK_BOX(custom_hbox), question_icon, FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(custom_hbox), custom_vbox, FALSE, FALSE,
+                     10);  // Make question icon 10px away from content
+  gtk_container_set_border_width(GTK_CONTAINER(custom_hbox), 2);
+  gtk_widget_show_all(custom_hbox);
+
+  gtk_box_pack_start(
+      GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(prompt_dialog))),
+      custom_hbox, FALSE, FALSE, 0);
+  gint diag_response = gtk_dialog_run(GTK_DIALOG(prompt_dialog));
+
+  if (diag_response == GTK_RESPONSE_ACCEPT) {
+    const gchar* response_text = gtk_entry_get_text(GTK_ENTRY(custom_entry));
+    g_object_set_data_full(G_OBJECT(changed_box), "custom-text",
+                           strdup(response_text), (GDestroyNotify)free);
+    g_object_set_data(G_OBJECT(changed_box), "previous-active",
+                      GINT_TO_POINTER(CUSTOM_VALUE_INDEX));
+  } else {
+    // Go back to the previous index
+    gint previous_active = GPOINTER_TO_INT(
+        g_object_get_data(G_OBJECT(changed_box), "previous-active"));
+    gtk_combo_box_set_active(changed_box, previous_active);
+  }
+
+  gtk_widget_destroy(prompt_dialog);
+}
+
+class nsPrintDialogWidgetGTK {
+ public:
+  nsPrintDialogWidgetGTK(nsPIDOMWindowOuter* aParent, bool aHaveSelection,
+                         nsIPrintSettings* aPrintSettings);
+  ~nsPrintDialogWidgetGTK() { gtk_widget_destroy(dialog); }
+  NS_ConvertUTF16toUTF8 GetUTF8FromBundle(const char* aKey);
+  gint Run();
+
+  nsresult ImportSettings(nsIPrintSettings* aNSSettings);
+  nsresult ExportSettings(nsIPrintSettings* aNSSettings);
+
+ private:
+  GtkWidget* dialog;
+  GtkWidget* shrink_to_fit_toggle;
+  GtkWidget* print_bg_colors_toggle;
+  GtkWidget* print_bg_images_toggle;
+  GtkWidget* selection_only_toggle;
+  GtkWidget* header_dropdown[3];  // {left, center, right}
+  GtkWidget* footer_dropdown[3];
+
+  nsCOMPtr<nsIStringBundle> printBundle;
+
+  bool useNativeSelection;
+
+  GtkWidget* ConstructHeaderFooterDropdown(const char16_t* currentString);
+  const char* OptionWidgetToString(GtkWidget* dropdown);
+
+  /* Code to copy between GTK and NS print settings structures.
+   * In the following,
+   *   "Import" means to copy from NS to GTK
+   *   "Export" means to copy from GTK to NS
+   */
+  void ExportHeaderFooter(nsIPrintSettings* aNS);
+};
+
+nsPrintDialogWidgetGTK::nsPrintDialogWidgetGTK(nsPIDOMWindowOuter* aParent,
+                                               bool aHaveSelection,
+                                               nsIPrintSettings* aSettings) {
+  nsCOMPtr<nsIWidget> widget = WidgetUtils::DOMWindowToWidget(aParent);
+  NS_ASSERTION(widget, "Need a widget for dialog to be modal.");
+  GtkWindow* gtkParent = get_gtk_window_for_nsiwidget(widget);
+  NS_ASSERTION(gtkParent, "Need a GTK window for dialog to be modal.");
+
+  nsCOMPtr<nsIStringBundleService> bundleSvc =
+      do_GetService(NS_STRINGBUNDLE_CONTRACTID);
+  bundleSvc->CreateBundle("chrome://global/locale/printdialog.properties",
+                          getter_AddRefs(printBundle));
+
+  dialog = gtk_print_unix_dialog_new(GetUTF8FromBundle("printTitleGTK").get(),
+                                     gtkParent);
+
+  gtk_print_unix_dialog_set_manual_capabilities(
+      GTK_PRINT_UNIX_DIALOG(dialog),
+      GtkPrintCapabilities(
+          GTK_PRINT_CAPABILITY_COPIES | GTK_PRINT_CAPABILITY_COLLATE |
+          GTK_PRINT_CAPABILITY_REVERSE | GTK_PRINT_CAPABILITY_SCALE |
+          GTK_PRINT_CAPABILITY_GENERATE_PDF));
+
+  // The vast majority of magic numbers in this widget construction are padding.
+  // e.g. for the set_border_width below, 12px matches that of just about every
+  // other window.
+  GtkWidget* custom_options_tab = gtk_vbox_new(FALSE, 0);
+  gtk_container_set_border_width(GTK_CONTAINER(custom_options_tab), 12);
+  GtkWidget* tab_label =
+      gtk_label_new(GetUTF8FromBundle("optionsTabLabelGTK").get());
+
+  // Check buttons for shrink-to-fit and print selection
+  GtkWidget* check_buttons_container = gtk_vbox_new(TRUE, 2);
+  shrink_to_fit_toggle = gtk_check_button_new_with_mnemonic(
+      GetUTF8FromBundle("shrinkToFit").get());
+  gtk_box_pack_start(GTK_BOX(check_buttons_container), shrink_to_fit_toggle,
+                     FALSE, FALSE, 0);
+
+  // GTK+2.18 and above allow us to add a "Selection" option to the main
+  // settings screen, rather than adding an option on a custom tab like we must
+  // do on older versions.
+  if (gtk_major_version > 2 ||
+      (gtk_major_version == 2 && gtk_minor_version >= 18)) {
+    useNativeSelection = true;
+    g_object_set(dialog, "support-selection", TRUE, "has-selection",
+                 aHaveSelection, "embed-page-setup", TRUE, nullptr);
+  } else {
+    useNativeSelection = false;
+    selection_only_toggle = gtk_check_button_new_with_mnemonic(
+        GetUTF8FromBundle("selectionOnly").get());
+    gtk_widget_set_sensitive(selection_only_toggle, aHaveSelection);
+    gtk_box_pack_start(GTK_BOX(check_buttons_container), selection_only_toggle,
+                       FALSE, FALSE, 0);
+  }
+
+  // Check buttons for printing background
+  GtkWidget* appearance_buttons_container = gtk_vbox_new(TRUE, 2);
+  print_bg_colors_toggle = gtk_check_button_new_with_mnemonic(
+      GetUTF8FromBundle("printBGColors").get());
+  print_bg_images_toggle = gtk_check_button_new_with_mnemonic(
+      GetUTF8FromBundle("printBGImages").get());
+  gtk_box_pack_start(GTK_BOX(appearance_buttons_container),
+                     print_bg_colors_toggle, FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(appearance_buttons_container),
+                     print_bg_images_toggle, FALSE, FALSE, 0);
+
+  // "Appearance" options label, bold and center-aligned
+  GtkWidget* appearance_label = gtk_label_new(nullptr);
+  char* pangoMarkup = g_markup_printf_escaped(
+      "<b>%s</b>", GetUTF8FromBundle("printBGOptions").get());
+  gtk_label_set_markup(GTK_LABEL(appearance_label), pangoMarkup);
+  g_free(pangoMarkup);
+  gtk_misc_set_alignment(GTK_MISC(appearance_label), 0, 0);
+
+  GtkWidget* appearance_container = gtk_alignment_new(0, 0, 0, 0);
+  gtk_alignment_set_padding(GTK_ALIGNMENT(appearance_container), 8, 0, 12, 0);
+  gtk_container_add(GTK_CONTAINER(appearance_container),
+                    appearance_buttons_container);
+
+  GtkWidget* appearance_vertical_squasher = gtk_vbox_new(FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(appearance_vertical_squasher), appearance_label,
+                     FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(appearance_vertical_squasher),
+                     appearance_container, FALSE, FALSE, 0);
+
+  // "Header & Footer" options label, bold and center-aligned
+  GtkWidget* header_footer_label = gtk_label_new(nullptr);
+  pangoMarkup = g_markup_printf_escaped(
+      "<b>%s</b>", GetUTF8FromBundle("headerFooter").get());
+  gtk_label_set_markup(GTK_LABEL(header_footer_label), pangoMarkup);
+  g_free(pangoMarkup);
+  gtk_misc_set_alignment(GTK_MISC(header_footer_label), 0, 0);
+
+  GtkWidget* header_footer_container = gtk_alignment_new(0, 0, 0, 0);
+  gtk_alignment_set_padding(GTK_ALIGNMENT(header_footer_container), 8, 0, 12,
+                            0);
+
+  // --- Table for making the header and footer options ---
+  GtkWidget* header_footer_table = gtk_table_new(3, 3, FALSE);  // 3x3 table
+  nsString header_footer_str[3];
+
+  aSettings->GetHeaderStrLeft(header_footer_str[0]);
+  aSettings->GetHeaderStrCenter(header_footer_str[1]);
+  aSettings->GetHeaderStrRight(header_footer_str[2]);
+
+  for (unsigned int i = 0; i < ArrayLength(header_dropdown); i++) {
+    header_dropdown[i] =
+        ConstructHeaderFooterDropdown(header_footer_str[i].get());
+    // Those 4 magic numbers in the middle provide the position in the table.
+    // The last two numbers mean 2 px padding on every side.
+    gtk_table_attach(GTK_TABLE(header_footer_table), header_dropdown[i], i,
+                     (i + 1), 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 2,
+                     2);
+  }
+
+  const char labelKeys[][7] = {"left", "center", "right"};
+  for (unsigned int i = 0; i < ArrayLength(labelKeys); i++) {
+    gtk_table_attach(GTK_TABLE(header_footer_table),
+                     gtk_label_new(GetUTF8FromBundle(labelKeys[i]).get()), i,
+                     (i + 1), 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 2,
+                     2);
+  }
+
+  aSettings->GetFooterStrLeft(header_footer_str[0]);
+  aSettings->GetFooterStrCenter(header_footer_str[1]);
+  aSettings->GetFooterStrRight(header_footer_str[2]);
+
+  for (unsigned int i = 0; i < ArrayLength(footer_dropdown); i++) {
+    footer_dropdown[i] =
+        ConstructHeaderFooterDropdown(header_footer_str[i].get());
+    gtk_table_attach(GTK_TABLE(header_footer_table), footer_dropdown[i], i,
+                     (i + 1), 2, 3, (GtkAttachOptions)0, (GtkAttachOptions)0, 2,
+                     2);
+  }
+  // ---
+
+  gtk_container_add(GTK_CONTAINER(header_footer_container),
+                    header_footer_table);
+
+  GtkWidget* header_footer_vertical_squasher = gtk_vbox_new(FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(header_footer_vertical_squasher),
+                     header_footer_label, FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(header_footer_vertical_squasher),
+                     header_footer_container, FALSE, FALSE, 0);
+
+  // Construction of everything
+  gtk_box_pack_start(GTK_BOX(custom_options_tab), check_buttons_container,
+                     FALSE, FALSE, 10);  // 10px padding
+  gtk_box_pack_start(GTK_BOX(custom_options_tab), appearance_vertical_squasher,
+                     FALSE, FALSE, 10);
+  gtk_box_pack_start(GTK_BOX(custom_options_tab),
+                     header_footer_vertical_squasher, FALSE, FALSE, 0);
+
+  gtk_print_unix_dialog_add_custom_tab(GTK_PRINT_UNIX_DIALOG(dialog),
+                                       custom_options_tab, tab_label);
+  gtk_widget_show_all(custom_options_tab);
+}
+
+NS_ConvertUTF16toUTF8 nsPrintDialogWidgetGTK::GetUTF8FromBundle(
+    const char* aKey) {
+  nsAutoString intlString;
+  printBundle->GetStringFromName(aKey, intlString);
+  return NS_ConvertUTF16toUTF8(
+      intlString);  // Return the actual object so we don't lose reference
+}
+
+const char* nsPrintDialogWidgetGTK::OptionWidgetToString(GtkWidget* dropdown) {
+  gint index = gtk_combo_box_get_active(GTK_COMBO_BOX(dropdown));
+
+  NS_ASSERTION(index <= CUSTOM_VALUE_INDEX,
+               "Index of dropdown is higher than expected!");
+
+  if (index == CUSTOM_VALUE_INDEX)
+    return (const char*)g_object_get_data(G_OBJECT(dropdown), "custom-text");
+  return header_footer_tags[index];
+}
+
+gint nsPrintDialogWidgetGTK::Run() {
+  const gint response = gtk_dialog_run(GTK_DIALOG(dialog));
+  gtk_widget_hide(dialog);
+  return response;
+}
+
+void nsPrintDialogWidgetGTK::ExportHeaderFooter(nsIPrintSettings* aNS) {
+  const char* header_footer_str;
+  header_footer_str = OptionWidgetToString(header_dropdown[0]);
+  aNS->SetHeaderStrLeft(NS_ConvertUTF8toUTF16(header_footer_str));
+
+  header_footer_str = OptionWidgetToString(header_dropdown[1]);
+  aNS->SetHeaderStrCenter(NS_ConvertUTF8toUTF16(header_footer_str));
+
+  header_footer_str = OptionWidgetToString(header_dropdown[2]);
+  aNS->SetHeaderStrRight(NS_ConvertUTF8toUTF16(header_footer_str));
+
+  header_footer_str = OptionWidgetToString(footer_dropdown[0]);
+  aNS->SetFooterStrLeft(NS_ConvertUTF8toUTF16(header_footer_str));
+
+  header_footer_str = OptionWidgetToString(footer_dropdown[1]);
+  aNS->SetFooterStrCenter(NS_ConvertUTF8toUTF16(header_footer_str));
+
+  header_footer_str = OptionWidgetToString(footer_dropdown[2]);
+  aNS->SetFooterStrRight(NS_ConvertUTF8toUTF16(header_footer_str));
+}
+
+nsresult nsPrintDialogWidgetGTK::ImportSettings(nsIPrintSettings* aNSSettings) {
+  MOZ_ASSERT(aNSSettings, "aSettings must not be null");
+  NS_ENSURE_TRUE(aNSSettings, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsPrintSettingsGTK> aNSSettingsGTK(do_QueryInterface(aNSSettings));
+  if (!aNSSettingsGTK) return NS_ERROR_FAILURE;
+
+  GtkPrintSettings* settings = aNSSettingsGTK->GetGtkPrintSettings();
+  GtkPageSetup* setup = aNSSettingsGTK->GetGtkPageSetup();
+
+  // Set our custom fields:
+
+  bool geckoBool;
+  aNSSettings->GetShrinkToFit(&geckoBool);
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shrink_to_fit_toggle),
+                               geckoBool);
+
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(print_bg_colors_toggle),
+                               aNSSettings->GetPrintBGColors());
+
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(print_bg_images_toggle),
+                               aNSSettings->GetPrintBGImages());
+
+  // Temporarily set the pages-per-sheet on the GtkPrintSettings:
+  int32_t pagesPerSide;
+  aNSSettings->GetNumPagesPerSheet(&pagesPerSide);
+  gtk_print_settings_set_number_up(settings, pagesPerSide);
+
+  gtk_print_unix_dialog_set_settings(GTK_PRINT_UNIX_DIALOG(dialog), settings);
+  gtk_print_unix_dialog_set_page_setup(GTK_PRINT_UNIX_DIALOG(dialog), setup);
+
+  return NS_OK;
+}
+
+nsresult nsPrintDialogWidgetGTK::ExportSettings(nsIPrintSettings* aNSSettings) {
+  MOZ_ASSERT(aNSSettings, "aSettings must not be null");
+  NS_ENSURE_TRUE(aNSSettings, NS_ERROR_FAILURE);
+
+  GtkPrintSettings* settings =
+      gtk_print_unix_dialog_get_settings(GTK_PRINT_UNIX_DIALOG(dialog));
+  GtkPageSetup* setup =
+      gtk_print_unix_dialog_get_page_setup(GTK_PRINT_UNIX_DIALOG(dialog));
+  GtkPrinter* printer =
+      gtk_print_unix_dialog_get_selected_printer(GTK_PRINT_UNIX_DIALOG(dialog));
+  if (settings && setup && printer) {
+    ExportHeaderFooter(aNSSettings);
+
+    aNSSettings->SetOutputFormat(nsIPrintSettings::kOutputFormatNative);
+
+    // Print-to-file is true by default. This must be turned off or else
+    // printing won't occur! (We manually copy the spool file when this flag is
+    // set, because we love our embedders) Even if it is print-to-file in GTK's
+    // case, GTK does The Right Thing when we send the job.
+    aNSSettings->SetOutputDestination(
+        nsIPrintSettings::kOutputDestinationPrinter);
+
+    aNSSettings->SetShrinkToFit(
+        gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(shrink_to_fit_toggle)));
+
+    aNSSettings->SetPrintBGColors(gtk_toggle_button_get_active(
+        GTK_TOGGLE_BUTTON(print_bg_colors_toggle)));
+    aNSSettings->SetPrintBGImages(gtk_toggle_button_get_active(
+        GTK_TOGGLE_BUTTON(print_bg_images_toggle)));
+
+    // Move any pages-per-sheet value from the GtkPrintSettings to our
+    // nsIPrintSettings. (We handle pages-per-sheet internally and don't want
+    // the native Linux printing code to doubly apply that value!)
+    int32_t pagesPerSide = gtk_print_settings_get_number_up(settings);
+    gtk_print_settings_set_number_up(settings, 1);
+    aNSSettings->SetNumPagesPerSheet(pagesPerSide);
+
+    // Try to save native settings in the session object
+    nsCOMPtr<nsPrintSettingsGTK> aNSSettingsGTK(do_QueryInterface(aNSSettings));
+    if (aNSSettingsGTK) {
+      aNSSettingsGTK->SetGtkPrintSettings(settings);
+      aNSSettingsGTK->SetGtkPageSetup(setup);
+      aNSSettingsGTK->SetGtkPrinter(printer);
+      bool printSelectionOnly;
+      if (useNativeSelection) {
+        _GtkPrintPages pageSetting =
+            (_GtkPrintPages)gtk_print_settings_get_print_pages(settings);
+        printSelectionOnly = (pageSetting == _GTK_PRINT_PAGES_SELECTION);
+      } else {
+        printSelectionOnly = gtk_toggle_button_get_active(
+            GTK_TOGGLE_BUTTON(selection_only_toggle));
+      }
+      aNSSettingsGTK->SetPrintSelectionOnly(printSelectionOnly);
+    }
+  }
+
+  if (settings) g_object_unref(settings);
+  return NS_OK;
+}
+
+GtkWidget* nsPrintDialogWidgetGTK::ConstructHeaderFooterDropdown(
+    const char16_t* currentString) {
+  GtkWidget* dropdown = gtk_combo_box_text_new();
+  const char hf_options[][22] = {"headerFooterBlank", "headerFooterTitle",
+                                 "headerFooterURL",   "headerFooterDate",
+                                 "headerFooterPage",  "headerFooterPageTotal",
+                                 "headerFooterCustom"};
+
+  for (unsigned int i = 0; i < ArrayLength(hf_options); i++) {
+    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(dropdown), nullptr,
+                              GetUTF8FromBundle(hf_options[i]).get());
+  }
+
+  bool shouldBeCustom = true;
+  NS_ConvertUTF16toUTF8 currentStringUTF8(currentString);
+
+  for (unsigned int i = 0; i < ArrayLength(header_footer_tags); i++) {
+    if (!strcmp(currentStringUTF8.get(), header_footer_tags[i])) {
+      gtk_combo_box_set_active(GTK_COMBO_BOX(dropdown), i);
+      g_object_set_data(G_OBJECT(dropdown), "previous-active",
+                        GINT_TO_POINTER(i));
+      shouldBeCustom = false;
+      break;
+    }
+  }
+
+  if (shouldBeCustom) {
+    gtk_combo_box_set_active(GTK_COMBO_BOX(dropdown), CUSTOM_VALUE_INDEX);
+    g_object_set_data(G_OBJECT(dropdown), "previous-active",
+                      GINT_TO_POINTER(CUSTOM_VALUE_INDEX));
+    char* custom_string = strdup(currentStringUTF8.get());
+    g_object_set_data_full(G_OBJECT(dropdown), "custom-text", custom_string,
+                           (GDestroyNotify)free);
+  }
+
+  g_signal_connect(dropdown, "changed", (GCallback)ShowCustomDialog, dialog);
+  return dropdown;
+}
+
+NS_IMPL_ISUPPORTS(nsPrintDialogServiceGTK, nsIPrintDialogService)
+
+nsPrintDialogServiceGTK::nsPrintDialogServiceGTK() = default;
+
+nsPrintDialogServiceGTK::~nsPrintDialogServiceGTK() = default;
+
+NS_IMETHODIMP
+nsPrintDialogServiceGTK::Init() { return NS_OK; }
+
+NS_IMETHODIMP
+nsPrintDialogServiceGTK::ShowPrintDialog(mozIDOMWindowProxy* aParent,
+                                         bool aHaveSelection,
+                                         nsIPrintSettings* aSettings) {
+  MOZ_ASSERT(aParent, "aParent must not be null");
+  MOZ_ASSERT(aSettings, "aSettings must not be null");
+
+  nsPrintDialogWidgetGTK printDialog(nsPIDOMWindowOuter::From(aParent),
+                                     aHaveSelection, aSettings);
+  nsresult rv = printDialog.ImportSettings(aSettings);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  const gint response = printDialog.Run();
+
+  // Handle the result
+  switch (response) {
+    case GTK_RESPONSE_OK:  // Proceed
+      rv = printDialog.ExportSettings(aSettings);
+      break;
+
+    case GTK_RESPONSE_CANCEL:
+    case GTK_RESPONSE_CLOSE:
+    case GTK_RESPONSE_DELETE_EVENT:
+    case GTK_RESPONSE_NONE:
+      rv = NS_ERROR_ABORT;
+      break;
+
+    case GTK_RESPONSE_APPLY:  // Print preview
+    default:
+      NS_WARNING("Unexpected response");
+      rv = NS_ERROR_ABORT;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsPrintDialogServiceGTK::ShowPageSetupDialog(mozIDOMWindowProxy* aParent,
+                                             nsIPrintSettings* aNSSettings) {
+  MOZ_ASSERT(aParent, "aParent must not be null");
+  MOZ_ASSERT(aNSSettings, "aSettings must not be null");
+  NS_ENSURE_TRUE(aNSSettings, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIWidget> widget =
+      WidgetUtils::DOMWindowToWidget(nsPIDOMWindowOuter::From(aParent));
+  NS_ASSERTION(widget, "Need a widget for dialog to be modal.");
+  GtkWindow* gtkParent = get_gtk_window_for_nsiwidget(widget);
+  NS_ASSERTION(gtkParent, "Need a GTK window for dialog to be modal.");
+
+  nsCOMPtr<nsPrintSettingsGTK> aNSSettingsGTK(do_QueryInterface(aNSSettings));
+  if (!aNSSettingsGTK) return NS_ERROR_FAILURE;
+
+  // We need to init the prefs here because aNSSettings in its current form is a
+  // dummy in both uses of the word
+  nsCOMPtr<nsIPrintSettingsService> psService =
+      do_GetService("@mozilla.org/gfx/printsettings-service;1");
+  if (psService) {
+    nsString printName;
+    aNSSettings->GetPrinterName(printName);
+    if (printName.IsVoid()) {
+      psService->GetLastUsedPrinterName(printName);
+      aNSSettings->SetPrinterName(printName);
+    }
+    psService->InitPrintSettingsFromPrefs(aNSSettings, true,
+                                          nsIPrintSettings::kInitSaveAll);
+  }
+
+  // Frustratingly, gtk_print_run_page_setup_dialog doesn't tell us whether
+  // the user cancelled or confirmed the dialog! So to avoid needlessly
+  // refreshing the preview when Page Setup was cancelled, we compare the
+  // serializations of old and new settings; if they're the same, bail out.
+  GtkPrintSettings* gtkSettings = aNSSettingsGTK->GetGtkPrintSettings();
+  GtkPageSetup* oldPageSetup = aNSSettingsGTK->GetGtkPageSetup();
+  GKeyFile* oldKeyFile = g_key_file_new();
+  gtk_page_setup_to_key_file(oldPageSetup, oldKeyFile, nullptr);
+  gsize oldLength;
+  gchar* oldData = g_key_file_to_data(oldKeyFile, &oldLength, nullptr);
+  g_key_file_free(oldKeyFile);
+
+  GtkPageSetup* newPageSetup =
+      gtk_print_run_page_setup_dialog(gtkParent, oldPageSetup, gtkSettings);
+
+  GKeyFile* newKeyFile = g_key_file_new();
+  gtk_page_setup_to_key_file(newPageSetup, newKeyFile, nullptr);
+  gsize newLength;
+  gchar* newData = g_key_file_to_data(newKeyFile, &newLength, nullptr);
+  g_key_file_free(newKeyFile);
+
+  bool unchanged =
+      (oldLength == newLength && !memcmp(oldData, newData, oldLength));
+  g_free(oldData);
+  g_free(newData);
+  if (unchanged) {
+    g_object_unref(newPageSetup);
+    return NS_ERROR_ABORT;
+  }
+
+  aNSSettingsGTK->SetGtkPageSetup(newPageSetup);
+
+  // Now newPageSetup has a refcount of 2 (SetGtkPageSetup will addref), put it
+  // to 1 so if this gets replaced we don't leak.
+  g_object_unref(newPageSetup);
+
+  if (psService)
+    psService->MaybeSavePrintSettingsToPrefs(
+        aNSSettings, nsIPrintSettings::kInitSaveOrientation |
+                         nsIPrintSettings::kInitSavePaperSize |
+                         nsIPrintSettings::kInitSaveUnwriteableMargins);
+
+  return NS_OK;
+}
diff --git a/widget/gtk/nsPrintDialogGTK.h b/widget/gtk/nsPrintDialogGTK.h
new file mode 100644
index 0000000000..4388962858
--- /dev/null
+++ b/widget/gtk/nsPrintDialogGTK.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsPrintDialog_h__
+#define nsPrintDialog_h__
+
+#include "nsIPrintDialogService.h"
+
+class nsIPrintSettings;
+
+// Copy the print pages enum here because not all versions
+// have SELECTION, which we will use
+typedef enum {
+  _GTK_PRINT_PAGES_ALL,
+  _GTK_PRINT_PAGES_CURRENT,
+  _GTK_PRINT_PAGES_RANGES,
+  _GTK_PRINT_PAGES_SELECTION
+} _GtkPrintPages;
+
+class nsPrintDialogServiceGTK final : public nsIPrintDialogService {
+  virtual ~nsPrintDialogServiceGTK();
+
+ public:
+  nsPrintDialogServiceGTK();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRINTDIALOGSERVICE
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsPrintDialogServiceGTK,
+                              NS_IPRINTDIALOGSERVICE_IID)
+
+#endif
diff --git a/widget/gtk/nsPrintSettingsGTK.cpp b/widget/gtk/nsPrintSettingsGTK.cpp
new file mode 100644
index 0000000000..6ca66a0fcf
--- /dev/null
+++ b/widget/gtk/nsPrintSettingsGTK.cpp
@@ -0,0 +1,677 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsPrintSettingsGTK.h"
+#include "nsIFile.h"
+#include "nsNetUtil.h"
+#include <stdlib.h>
+#include <algorithm>
+
+// These constants are the the strings that GTK expects as key-value pairs for
+// setting CUPS duplex modes. These are not universal to all CUPS systems, which
+// is why they are local to this file.
+static constexpr gchar kCupsDuplex[] = "cups-Duplex";
+static constexpr gchar kCupsDuplexNone[] = "None";
+static constexpr gchar kCupsDuplexNoTumble[] = "DuplexNoTumble";
+static constexpr gchar kCupsDuplexTumble[] = "DuplexTumble";
+
+static GtkPaperSize* moz_gtk_paper_size_copy_to_new_custom(
+    GtkPaperSize* oldPaperSize) {
+  // We make a "custom-ified" copy of the paper size so it can be changed later.
+  return gtk_paper_size_new_custom(
+      gtk_paper_size_get_name(oldPaperSize),
+      gtk_paper_size_get_display_name(oldPaperSize),
+      gtk_paper_size_get_width(oldPaperSize, GTK_UNIT_INCH),
+      gtk_paper_size_get_height(oldPaperSize, GTK_UNIT_INCH), GTK_UNIT_INCH);
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsPrintSettingsGTK, nsPrintSettings,
+                            nsPrintSettingsGTK)
+
+/** ---------------------------------------------------
+ */
+nsPrintSettingsGTK::nsPrintSettingsGTK()
+    : mPageSetup(nullptr), mPrintSettings(nullptr), mGTKPrinter(nullptr) {
+  // The aim here is to set up the objects enough that silent printing works
+  // well. These will be replaced anyway if the print dialog is used.
+  mPrintSettings = gtk_print_settings_new();
+  GtkPageSetup* pageSetup = gtk_page_setup_new();
+  SetGtkPageSetup(pageSetup);
+  g_object_unref(pageSetup);
+
+  SetOutputFormat(nsIPrintSettings::kOutputFormatNative);
+}
+
+already_AddRefed<nsIPrintSettings> CreatePlatformPrintSettings(
+    const mozilla::PrintSettingsInitializer& aSettings) {
+  RefPtr<nsPrintSettings> settings = new nsPrintSettingsGTK();
+  settings->InitWithInitializer(aSettings);
+  settings->SetDefaultFileName();
+  return settings.forget();
+}
+
+/** ---------------------------------------------------
+ */
+nsPrintSettingsGTK::~nsPrintSettingsGTK() {
+  if (mPageSetup) {
+    g_object_unref(mPageSetup);
+    mPageSetup = nullptr;
+  }
+  if (mPrintSettings) {
+    g_object_unref(mPrintSettings);
+    mPrintSettings = nullptr;
+  }
+  if (mGTKPrinter) {
+    g_object_unref(mGTKPrinter);
+    mGTKPrinter = nullptr;
+  }
+}
+
+/** ---------------------------------------------------
+ */
+nsPrintSettingsGTK::nsPrintSettingsGTK(const nsPrintSettingsGTK& aPS)
+    : mPageSetup(nullptr), mPrintSettings(nullptr), mGTKPrinter(nullptr) {
+  *this = aPS;
+}
+
+/** ---------------------------------------------------
+ */
+nsPrintSettingsGTK& nsPrintSettingsGTK::operator=(
+    const nsPrintSettingsGTK& rhs) {
+  if (this == &rhs) {
+    return *this;
+  }
+
+  nsPrintSettings::operator=(rhs);
+
+  if (mPageSetup) g_object_unref(mPageSetup);
+  mPageSetup = gtk_page_setup_copy(rhs.mPageSetup);
+  // NOTE: No need to re-initialize mUnwriteableMargin here (even
+  // though mPageSetup is changing). It'll be copied correctly by
+  // nsPrintSettings::operator=.
+
+  if (mPrintSettings) g_object_unref(mPrintSettings);
+  mPrintSettings = gtk_print_settings_copy(rhs.mPrintSettings);
+
+  if (mGTKPrinter) g_object_unref(mGTKPrinter);
+  mGTKPrinter = (GtkPrinter*)g_object_ref(rhs.mGTKPrinter);
+
+  return *this;
+}
+
+/** -------------------------------------------
+ */
+nsresult nsPrintSettingsGTK::_Clone(nsIPrintSettings** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = nullptr;
+
+  nsPrintSettingsGTK* newSettings = new nsPrintSettingsGTK(*this);
+  if (!newSettings) return NS_ERROR_FAILURE;
+  *_retval = newSettings;
+  NS_ADDREF(*_retval);
+  return NS_OK;
+}
+
+/** -------------------------------------------
+ */
+NS_IMETHODIMP
+nsPrintSettingsGTK::_Assign(nsIPrintSettings* aPS) {
+  nsPrintSettingsGTK* printSettingsGTK = static_cast<nsPrintSettingsGTK*>(aPS);
+  if (!printSettingsGTK) return NS_ERROR_UNEXPECTED;
+  *this = *printSettingsGTK;
+  return NS_OK;
+}
+
+/** ---------------------------------------------------
+ */
+void nsPrintSettingsGTK::SetGtkPageSetup(GtkPageSetup* aPageSetup) {
+  if (mPageSetup) g_object_unref(mPageSetup);
+
+  mPageSetup = (GtkPageSetup*)g_object_ref(aPageSetup);
+  InitUnwriteableMargin();
+
+  // If the paper size is not custom, then we make a custom copy of the
+  // GtkPaperSize, so it can be mutable. If a GtkPaperSize wasn't made as
+  // custom, its properties are immutable.
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(aPageSetup);
+  if (!gtk_paper_size_is_custom(paperSize)) {
+    GtkPaperSize* customPaperSize =
+        moz_gtk_paper_size_copy_to_new_custom(paperSize);
+    gtk_page_setup_set_paper_size(mPageSetup, customPaperSize);
+    gtk_paper_size_free(customPaperSize);
+  }
+  SaveNewPageSize();
+}
+
+/** ---------------------------------------------------
+ */
+void nsPrintSettingsGTK::SetGtkPrintSettings(GtkPrintSettings* aPrintSettings) {
+  if (mPrintSettings) g_object_unref(mPrintSettings);
+
+  mPrintSettings = (GtkPrintSettings*)g_object_ref(aPrintSettings);
+
+  GtkPaperSize* paperSize = gtk_print_settings_get_paper_size(aPrintSettings);
+  if (paperSize) {
+    GtkPaperSize* customPaperSize =
+        moz_gtk_paper_size_copy_to_new_custom(paperSize);
+    gtk_paper_size_free(paperSize);
+    gtk_page_setup_set_paper_size(mPageSetup, customPaperSize);
+    gtk_paper_size_free(customPaperSize);
+  } else {
+    // paperSize was null, and so we add the paper size in the GtkPageSetup to
+    // the settings.
+    SaveNewPageSize();
+  }
+}
+
+/** ---------------------------------------------------
+ */
+void nsPrintSettingsGTK::SetGtkPrinter(GtkPrinter* aPrinter) {
+  if (mGTKPrinter) g_object_unref(mGTKPrinter);
+
+  mGTKPrinter = (GtkPrinter*)g_object_ref(aPrinter);
+}
+
+NS_IMETHODIMP nsPrintSettingsGTK::GetOutputFormat(int16_t* aOutputFormat) {
+  NS_ENSURE_ARG_POINTER(aOutputFormat);
+
+  int16_t format;
+  nsresult rv = nsPrintSettings::GetOutputFormat(&format);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (format == nsIPrintSettings::kOutputFormatNative &&
+      GTK_IS_PRINTER(mGTKPrinter)) {
+    format = nsIPrintSettings::kOutputFormatPDF;
+  }
+
+  *aOutputFormat = format;
+  return NS_OK;
+}
+
+/**
+ * Reimplementation of nsPrintSettings functions so that we get the values
+ * from the GTK objects rather than our own variables.
+ */
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPageRanges(const nsTArray<int32_t>& aRanges) {
+  if (aRanges.Length() % 2 != 0) {
+    return NS_ERROR_FAILURE;
+  }
+
+  gtk_print_settings_set_print_pages(
+      mPrintSettings,
+      aRanges.IsEmpty() ? GTK_PRINT_PAGES_ALL : GTK_PRINT_PAGES_RANGES);
+
+  nsTArray<GtkPageRange> ranges;
+  ranges.SetCapacity(aRanges.Length() / 2);
+  for (size_t i = 0; i < aRanges.Length(); i += 2) {
+    GtkPageRange* gtkRange = ranges.AppendElement();
+    gtkRange->start = aRanges[i] - 1;
+    gtkRange->end = aRanges[i + 1] - 1;
+  }
+
+  gtk_print_settings_set_page_ranges(mPrintSettings, ranges.Elements(),
+                                     ranges.Length());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPrintReversed(bool* aPrintReversed) {
+  *aPrintReversed = gtk_print_settings_get_reverse(mPrintSettings);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPrintReversed(bool aPrintReversed) {
+  gtk_print_settings_set_reverse(mPrintSettings, aPrintReversed);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPrintInColor(bool* aPrintInColor) {
+  *aPrintInColor = gtk_print_settings_get_use_color(mPrintSettings);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPrintInColor(bool aPrintInColor) {
+  gtk_print_settings_set_use_color(mPrintSettings, aPrintInColor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetOrientation(int32_t* aOrientation) {
+  NS_ENSURE_ARG_POINTER(aOrientation);
+
+  GtkPageOrientation gtkOrient = gtk_page_setup_get_orientation(mPageSetup);
+  switch (gtkOrient) {
+    case GTK_PAGE_ORIENTATION_LANDSCAPE:
+    case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
+      *aOrientation = kLandscapeOrientation;
+      break;
+
+    case GTK_PAGE_ORIENTATION_PORTRAIT:
+    case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
+    default:
+      *aOrientation = kPortraitOrientation;
+  }
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetOrientation(int32_t aOrientation) {
+  GtkPageOrientation gtkOrient;
+  if (aOrientation == kLandscapeOrientation)
+    gtkOrient = GTK_PAGE_ORIENTATION_LANDSCAPE;
+  else
+    gtkOrient = GTK_PAGE_ORIENTATION_PORTRAIT;
+
+  gtk_print_settings_set_orientation(mPrintSettings, gtkOrient);
+  gtk_page_setup_set_orientation(mPageSetup, gtkOrient);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetToFileName(nsAString& aToFileName) {
+  // Get the gtk output filename
+  const char* gtk_output_uri =
+      gtk_print_settings_get(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI);
+  if (!gtk_output_uri) {
+    aToFileName = mToFileName;
+    return NS_OK;
+  }
+
+  // Convert to an nsIFile
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = NS_GetFileFromURLSpec(nsDependentCString(gtk_output_uri),
+                                      getter_AddRefs(file));
+  if (NS_FAILED(rv)) return rv;
+
+  // Extract the path
+  return file->GetPath(aToFileName);
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetToFileName(const nsAString& aToFileName) {
+  if (aToFileName.IsEmpty()) {
+    mToFileName.SetLength(0);
+    gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI,
+                           nullptr);
+    return NS_OK;
+  }
+
+  gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT,
+                         "pdf");
+
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = NS_NewLocalFile(aToFileName, true, getter_AddRefs(file));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Convert the nsIFile to a URL
+  nsAutoCString url;
+  rv = NS_GetURLSpecFromFile(file, url);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  gtk_print_settings_set(mPrintSettings, GTK_PRINT_SETTINGS_OUTPUT_URI,
+                         url.get());
+  mToFileName = aToFileName;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPrinterName(nsAString& aPrinter) {
+  const char* gtkPrintName = gtk_print_settings_get_printer(mPrintSettings);
+  if (!gtkPrintName) {
+    if (GTK_IS_PRINTER(mGTKPrinter)) {
+      gtkPrintName = gtk_printer_get_name(mGTKPrinter);
+    } else {
+      // This mimics what nsPrintSettingsImpl does when we try to Get before we
+      // Set
+      aPrinter.Truncate();
+      return NS_OK;
+    }
+  }
+  CopyUTF8toUTF16(mozilla::MakeStringSpan(gtkPrintName), aPrinter);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPrinterName(const nsAString& aPrinter) {
+  NS_ConvertUTF16toUTF8 gtkPrinter(aPrinter);
+
+  if (StringBeginsWith(gtkPrinter, "CUPS/"_ns)) {
+    // Strip off "CUPS/"; GTK might recognize the rest
+    gtkPrinter.Cut(0, strlen("CUPS/"));
+  }
+
+  // Give mPrintSettings the passed-in printer name if either...
+  // - it has no printer name stored yet
+  // - it has an existing printer name that's different from
+  //   the name passed to this function.
+  const char* oldPrinterName = gtk_print_settings_get_printer(mPrintSettings);
+  if (!oldPrinterName || !gtkPrinter.Equals(oldPrinterName)) {
+    mIsInitedFromPrinter = false;
+    mIsInitedFromPrefs = false;
+    gtk_print_settings_set_printer(mPrintSettings, gtkPrinter.get());
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetNumCopies(int32_t* aNumCopies) {
+  NS_ENSURE_ARG_POINTER(aNumCopies);
+  *aNumCopies = gtk_print_settings_get_n_copies(mPrintSettings);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetNumCopies(int32_t aNumCopies) {
+  gtk_print_settings_set_n_copies(mPrintSettings, aNumCopies);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetScaling(double* aScaling) {
+  *aScaling = gtk_print_settings_get_scale(mPrintSettings) / 100.0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetScaling(double aScaling) {
+  gtk_print_settings_set_scale(mPrintSettings, aScaling * 100.0);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPaperId(nsAString& aPaperId) {
+  const gchar* name =
+      gtk_paper_size_get_name(gtk_page_setup_get_paper_size(mPageSetup));
+  CopyUTF8toUTF16(mozilla::MakeStringSpan(name), aPaperId);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPaperId(const nsAString& aPaperId) {
+  NS_ConvertUTF16toUTF8 gtkPaperName(aPaperId);
+
+  // Convert these Gecko names to GTK names
+  // XXX (jfkthame): is this still relevant?
+  if (gtkPaperName.EqualsIgnoreCase("letter"))
+    gtkPaperName.AssignLiteral(GTK_PAPER_NAME_LETTER);
+  else if (gtkPaperName.EqualsIgnoreCase("legal"))
+    gtkPaperName.AssignLiteral(GTK_PAPER_NAME_LEGAL);
+
+  GtkPaperSize* oldPaperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  gdouble width = gtk_paper_size_get_width(oldPaperSize, GTK_UNIT_INCH);
+  gdouble height = gtk_paper_size_get_height(oldPaperSize, GTK_UNIT_INCH);
+
+  // Try to get the display name from the name so our paper size fits in the
+  // Page Setup dialog.
+  GtkPaperSize* paperSize = gtk_paper_size_new(gtkPaperName.get());
+  GtkPaperSize* customPaperSize = gtk_paper_size_new_custom(
+      gtkPaperName.get(), gtk_paper_size_get_display_name(paperSize), width,
+      height, GTK_UNIT_INCH);
+  gtk_paper_size_free(paperSize);
+
+  gtk_page_setup_set_paper_size(mPageSetup, customPaperSize);
+  gtk_paper_size_free(customPaperSize);
+  SaveNewPageSize();
+  return NS_OK;
+}
+
+GtkUnit nsPrintSettingsGTK::GetGTKUnit(int16_t aGeckoUnit) {
+  if (aGeckoUnit == kPaperSizeMillimeters)
+    return GTK_UNIT_MM;
+  else
+    return GTK_UNIT_INCH;
+}
+
+void nsPrintSettingsGTK::SaveNewPageSize() {
+  gtk_print_settings_set_paper_size(mPrintSettings,
+                                    gtk_page_setup_get_paper_size(mPageSetup));
+}
+
+void nsPrintSettingsGTK::InitUnwriteableMargin() {
+  mUnwriteableMargin.SizeTo(
+      NS_INCHES_TO_INT_TWIPS(
+          gtk_page_setup_get_top_margin(mPageSetup, GTK_UNIT_INCH)),
+      NS_INCHES_TO_INT_TWIPS(
+          gtk_page_setup_get_right_margin(mPageSetup, GTK_UNIT_INCH)),
+      NS_INCHES_TO_INT_TWIPS(
+          gtk_page_setup_get_bottom_margin(mPageSetup, GTK_UNIT_INCH)),
+      NS_INCHES_TO_INT_TWIPS(
+          gtk_page_setup_get_left_margin(mPageSetup, GTK_UNIT_INCH)));
+}
+
+/**
+ * NOTE: Need a custom set of SetUnwriteableMargin functions, because
+ * whenever we change mUnwriteableMargin, we must pass the change
+ * down to our GTKPageSetup object.  (This is needed in order for us
+ * to give the correct default values in nsPrintDialogGTK.)
+ *
+ * It's important that the following functions pass
+ * mUnwriteableMargin values rather than aUnwriteableMargin values
+ * to gtk_page_setup_set_[blank]_margin, because the two may not be
+ * the same.  (Specifically, negative values of aUnwriteableMargin
+ * are ignored by the nsPrintSettings::SetUnwriteableMargin functions.)
+ */
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetUnwriteableMarginInTwips(
+    nsIntMargin& aUnwriteableMargin) {
+  nsPrintSettings::SetUnwriteableMarginInTwips(aUnwriteableMargin);
+  gtk_page_setup_set_top_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.top), GTK_UNIT_INCH);
+  gtk_page_setup_set_left_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.left), GTK_UNIT_INCH);
+  gtk_page_setup_set_bottom_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom), GTK_UNIT_INCH);
+  gtk_page_setup_set_right_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.right), GTK_UNIT_INCH);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetUnwriteableMarginTop(double aUnwriteableMarginTop) {
+  nsPrintSettings::SetUnwriteableMarginTop(aUnwriteableMarginTop);
+  gtk_page_setup_set_top_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.top), GTK_UNIT_INCH);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetUnwriteableMarginLeft(double aUnwriteableMarginLeft) {
+  nsPrintSettings::SetUnwriteableMarginLeft(aUnwriteableMarginLeft);
+  gtk_page_setup_set_left_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.left), GTK_UNIT_INCH);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetUnwriteableMarginBottom(
+    double aUnwriteableMarginBottom) {
+  nsPrintSettings::SetUnwriteableMarginBottom(aUnwriteableMarginBottom);
+  gtk_page_setup_set_bottom_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom), GTK_UNIT_INCH);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetUnwriteableMarginRight(double aUnwriteableMarginRight) {
+  nsPrintSettings::SetUnwriteableMarginRight(aUnwriteableMarginRight);
+  gtk_page_setup_set_right_margin(
+      mPageSetup, NS_TWIPS_TO_INCHES(mUnwriteableMargin.right), GTK_UNIT_INCH);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPaperWidth(double* aPaperWidth) {
+  NS_ENSURE_ARG_POINTER(aPaperWidth);
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  *aPaperWidth =
+      gtk_paper_size_get_width(paperSize, GetGTKUnit(mPaperSizeUnit));
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPaperWidth(double aPaperWidth) {
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  gtk_paper_size_set_size(
+      paperSize, aPaperWidth,
+      gtk_paper_size_get_height(paperSize, GetGTKUnit(mPaperSizeUnit)),
+      GetGTKUnit(mPaperSizeUnit));
+  SaveNewPageSize();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPaperHeight(double* aPaperHeight) {
+  NS_ENSURE_ARG_POINTER(aPaperHeight);
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  *aPaperHeight =
+      gtk_paper_size_get_height(paperSize, GetGTKUnit(mPaperSizeUnit));
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPaperHeight(double aPaperHeight) {
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  gtk_paper_size_set_size(
+      paperSize,
+      gtk_paper_size_get_width(paperSize, GetGTKUnit(mPaperSizeUnit)),
+      aPaperHeight, GetGTKUnit(mPaperSizeUnit));
+  SaveNewPageSize();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetPaperSizeUnit(int16_t aPaperSizeUnit) {
+  // Convert units internally. e.g. they might have set the values while we're
+  // still in mm but they change to inch just afterwards, expecting that their
+  // sizes are in inches.
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  gtk_paper_size_set_size(
+      paperSize,
+      gtk_paper_size_get_width(paperSize, GetGTKUnit(mPaperSizeUnit)),
+      gtk_paper_size_get_height(paperSize, GetGTKUnit(mPaperSizeUnit)),
+      GetGTKUnit(aPaperSizeUnit));
+  SaveNewPageSize();
+
+  mPaperSizeUnit = aPaperSizeUnit;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetEffectivePageSize(double* aWidth, double* aHeight) {
+  GtkPaperSize* paperSize = gtk_page_setup_get_paper_size(mPageSetup);
+  if (mPaperSizeUnit == kPaperSizeInches) {
+    *aWidth =
+        NS_INCHES_TO_TWIPS(gtk_paper_size_get_width(paperSize, GTK_UNIT_INCH));
+    *aHeight =
+        NS_INCHES_TO_TWIPS(gtk_paper_size_get_height(paperSize, GTK_UNIT_INCH));
+  } else {
+    MOZ_ASSERT(mPaperSizeUnit == kPaperSizeMillimeters,
+               "unexpected paper size unit");
+    *aWidth = NS_MILLIMETERS_TO_TWIPS(
+        gtk_paper_size_get_width(paperSize, GTK_UNIT_MM));
+    *aHeight = NS_MILLIMETERS_TO_TWIPS(
+        gtk_paper_size_get_height(paperSize, GTK_UNIT_MM));
+  }
+  GtkPageOrientation gtkOrient = gtk_page_setup_get_orientation(mPageSetup);
+
+  if (gtkOrient == GTK_PAGE_ORIENTATION_LANDSCAPE ||
+      gtkOrient == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE) {
+    double temp = *aWidth;
+    *aWidth = *aHeight;
+    *aHeight = temp;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetPageRanges(nsTArray<int32_t>& aPages) {
+  GtkPrintPages gtkRange = gtk_print_settings_get_print_pages(mPrintSettings);
+  if (gtkRange != GTK_PRINT_PAGES_RANGES) {
+    aPages.Clear();
+    return NS_OK;
+  }
+
+  gint ctRanges;
+  GtkPageRange* lstRanges =
+      gtk_print_settings_get_page_ranges(mPrintSettings, &ctRanges);
+
+  aPages.Clear();
+
+  for (gint i = 0; i < ctRanges; i++) {
+    aPages.AppendElement(lstRanges[i].start + 1);
+    aPages.AppendElement(lstRanges[i].end + 1);
+  }
+
+  g_free(lstRanges);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetResolution(int32_t* aResolution) {
+  *aResolution = gtk_print_settings_get_resolution(mPrintSettings);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetResolution(int32_t aResolution) {
+  gtk_print_settings_set_resolution(mPrintSettings, aResolution);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::GetDuplex(int32_t* aDuplex) {
+  NS_ENSURE_ARG_POINTER(aDuplex);
+
+  // Default to DuplexNone.
+  *aDuplex = kDuplexNone;
+
+  if (!gtk_print_settings_has_key(mPrintSettings, GTK_PRINT_SETTINGS_DUPLEX)) {
+    return NS_OK;
+  }
+
+  switch (gtk_print_settings_get_duplex(mPrintSettings)) {
+    case GTK_PRINT_DUPLEX_SIMPLEX:
+      *aDuplex = kDuplexNone;
+      break;
+    case GTK_PRINT_DUPLEX_HORIZONTAL:
+      *aDuplex = kDuplexFlipOnLongEdge;
+      break;
+    case GTK_PRINT_DUPLEX_VERTICAL:
+      *aDuplex = kDuplexFlipOnShortEdge;
+      break;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsGTK::SetDuplex(int32_t aDuplex) {
+  uint32_t duplex = static_cast<uint32_t>(aDuplex);
+  MOZ_ASSERT(duplex <= kDuplexFlipOnShortEdge,
+             "value is out of bounds for duplex enum");
+
+  // We want to set the GTK CUPS Duplex setting in addition to calling
+  // gtk_print_settings_set_duplex(). Some systems may look for one, or the
+  // other, so it is best to set them both consistently.
+  switch (duplex) {
+    case kDuplexNone:
+      gtk_print_settings_set(mPrintSettings, kCupsDuplex, kCupsDuplexNone);
+      gtk_print_settings_set_duplex(mPrintSettings, GTK_PRINT_DUPLEX_SIMPLEX);
+      break;
+    case kDuplexFlipOnLongEdge:
+      gtk_print_settings_set(mPrintSettings, kCupsDuplex, kCupsDuplexNoTumble);
+      gtk_print_settings_set_duplex(mPrintSettings,
+                                    GTK_PRINT_DUPLEX_HORIZONTAL);
+      break;
+    case kDuplexFlipOnShortEdge:
+      gtk_print_settings_set(mPrintSettings, kCupsDuplex, kCupsDuplexTumble);
+      gtk_print_settings_set_duplex(mPrintSettings, GTK_PRINT_DUPLEX_VERTICAL);
+      break;
+  }
+
+  return NS_OK;
+}
diff --git a/widget/gtk/nsPrintSettingsGTK.h b/widget/gtk/nsPrintSettingsGTK.h
new file mode 100644
index 0000000000..c2d97a6208
--- /dev/null
+++ b/widget/gtk/nsPrintSettingsGTK.h
@@ -0,0 +1,147 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsPrintSettingsGTK_h_
+#define nsPrintSettingsGTK_h_
+
+#include "nsPrintSettingsImpl.h"
+
+extern "C" {
+#include <gtk/gtk.h>
+#include <gtk/gtkunixprint.h>
+}
+
+#define NS_PRINTSETTINGSGTK_IID                      \
+  {                                                  \
+    0x758df520, 0xc7c3, 0x11dc, {                    \
+      0x95, 0xff, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 \
+    }                                                \
+  }
+
+//*****************************************************************************
+//***    nsPrintSettingsGTK
+//*****************************************************************************
+
+class nsPrintSettingsGTK : public nsPrintSettings {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_PRINTSETTINGSGTK_IID)
+
+  nsPrintSettingsGTK();
+  explicit nsPrintSettingsGTK(const PrintSettingsInitializer& aSettings);
+
+  static nsPrintSettingsGTK* From(nsIPrintSettings* aPrintSettings) {
+    return static_cast<nsPrintSettingsGTK*>(aPrintSettings);
+  }
+
+  // We're overriding these methods because we want to read/write with GTK
+  // objects, not local variables. This allows a simpler settings implementation
+  // between Gecko and GTK.
+
+  GtkPageSetup* GetGtkPageSetup() { return mPageSetup; };
+  void SetGtkPageSetup(GtkPageSetup* aPageSetup);
+
+  GtkPrintSettings* GetGtkPrintSettings() { return mPrintSettings; };
+  void SetGtkPrintSettings(GtkPrintSettings* aPrintSettings);
+
+  GtkPrinter* GetGtkPrinter() { return mGTKPrinter; };
+  void SetGtkPrinter(GtkPrinter* aPrinter);
+
+  // Reversed, color, orientation and file name are all stored in the
+  // GtkPrintSettings. Orientation is also stored in the GtkPageSetup and its
+  // setting takes priority when getting the orientation.
+  NS_IMETHOD GetPrintReversed(bool* aPrintReversed) override;
+  NS_IMETHOD SetPrintReversed(bool aPrintReversed) override;
+
+  NS_IMETHOD GetPrintInColor(bool* aPrintInColor) override;
+  NS_IMETHOD SetPrintInColor(bool aPrintInColor) override;
+
+  NS_IMETHOD GetOrientation(int32_t* aOrientation) override;
+  NS_IMETHOD SetOrientation(int32_t aOrientation) override;
+
+  NS_IMETHOD GetToFileName(nsAString& aToFileName) override;
+  NS_IMETHOD SetToFileName(const nsAString& aToFileName) override;
+
+  // Gets/Sets the printer name in the GtkPrintSettings. If no printer name is
+  // specified there, you will get back the name of the current internal
+  // GtkPrinter.
+  NS_IMETHOD GetPrinterName(nsAString& Printer) override;
+  NS_IMETHOD SetPrinterName(const nsAString& aPrinter) override;
+
+  // Number of copies is stored/gotten from the GtkPrintSettings.
+  NS_IMETHOD GetNumCopies(int32_t* aNumCopies) override;
+  NS_IMETHOD SetNumCopies(int32_t aNumCopies) override;
+
+  NS_IMETHOD GetScaling(double* aScaling) override;
+  NS_IMETHOD SetScaling(double aScaling) override;
+
+  // A name recognised by GTK is strongly advised here, as this is used to
+  // create a GtkPaperSize.
+  NS_IMETHOD GetPaperId(nsAString& aPaperId) override;
+  NS_IMETHOD SetPaperId(const nsAString& aPaperId) override;
+
+  NS_IMETHOD SetUnwriteableMarginInTwips(
+      nsIntMargin& aUnwriteableMargin) override;
+  NS_IMETHOD SetUnwriteableMarginTop(double aUnwriteableMarginTop) override;
+  NS_IMETHOD SetUnwriteableMarginLeft(double aUnwriteableMarginLeft) override;
+  NS_IMETHOD SetUnwriteableMarginBottom(
+      double aUnwriteableMarginBottom) override;
+  NS_IMETHOD SetUnwriteableMarginRight(double aUnwriteableMarginRight) override;
+
+  NS_IMETHOD GetPaperWidth(double* aPaperWidth) override;
+  NS_IMETHOD SetPaperWidth(double aPaperWidth) override;
+
+  NS_IMETHOD GetPaperHeight(double* aPaperHeight) override;
+  NS_IMETHOD SetPaperHeight(double aPaperHeight) override;
+
+  NS_IMETHOD SetPaperSizeUnit(int16_t aPaperSizeUnit) override;
+
+  NS_IMETHOD GetEffectivePageSize(double* aWidth, double* aHeight) override;
+
+  NS_IMETHOD SetPageRanges(const nsTArray<int32_t>&) override;
+  NS_IMETHOD GetPageRanges(nsTArray<int32_t>&) override;
+
+  NS_IMETHOD GetResolution(int32_t* aResolution) override;
+  NS_IMETHOD SetResolution(int32_t aResolution) override;
+
+  NS_IMETHOD GetDuplex(int32_t* aDuplex) override;
+  NS_IMETHOD SetDuplex(int32_t aDuplex) override;
+
+  NS_IMETHOD GetOutputFormat(int16_t* aOutputFormat) override;
+
+ protected:
+  virtual ~nsPrintSettingsGTK();
+
+  nsPrintSettingsGTK(const nsPrintSettingsGTK& src);
+  nsPrintSettingsGTK& operator=(const nsPrintSettingsGTK& rhs);
+
+  virtual nsresult _Clone(nsIPrintSettings** _retval) override;
+  virtual nsresult _Assign(nsIPrintSettings* aPS) override;
+
+  GtkUnit GetGTKUnit(int16_t aGeckoUnit);
+  void SaveNewPageSize();
+
+  /**
+   * Re-initialize mUnwriteableMargin with values from mPageSetup.
+   * Should be called whenever mPageSetup is initialized or overwritten.
+   */
+  void InitUnwriteableMargin();
+
+  /**
+   * On construction:
+   * - mPrintSettings and mPageSetup are just new objects with defaults
+   *   determined by GTK.
+   * - mGTKPrinter is nullptr!!! Remember to be careful when accessing this
+   *   property.
+   */
+  GtkPageSetup* mPageSetup;
+  GtkPrintSettings* mPrintSettings;
+  GtkPrinter* mGTKPrinter;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsPrintSettingsGTK, NS_PRINTSETTINGSGTK_IID)
+
+#endif  // nsPrintSettingsGTK_h_
diff --git a/widget/gtk/nsPrintSettingsServiceGTK.cpp b/widget/gtk/nsPrintSettingsServiceGTK.cpp
new file mode 100644
index 0000000000..9d0dfc9379
--- /dev/null
+++ b/widget/gtk/nsPrintSettingsServiceGTK.cpp
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsPrintSettingsServiceGTK.h"
+
+#include "mozilla/embedding/PPrintingTypes.h"
+#include "nsPrintSettingsGTK.h"
+
+using namespace mozilla::embedding;
+
+static void serialize_gtk_printsettings_to_printdata(const gchar* key,
+                                                     const gchar* value,
+                                                     gpointer aData) {
+  PrintData* data = (PrintData*)aData;
+  CStringKeyValue pair;
+  pair.key() = key;
+  pair.value() = value;
+  data->GTKPrintSettings().AppendElement(pair);
+}
+
+NS_IMETHODIMP
+nsPrintSettingsServiceGTK::SerializeToPrintData(nsIPrintSettings* aSettings,
+                                                PrintData* data) {
+  nsresult rv = nsPrintSettingsService::SerializeToPrintData(aSettings, data);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsPrintSettingsGTK> settingsGTK(do_QueryInterface(aSettings));
+  NS_ENSURE_STATE(settingsGTK);
+
+  GtkPrintSettings* gtkPrintSettings = settingsGTK->GetGtkPrintSettings();
+  NS_ENSURE_STATE(gtkPrintSettings);
+
+  gtk_print_settings_foreach(gtkPrintSettings,
+                             serialize_gtk_printsettings_to_printdata, data);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsServiceGTK::DeserializeToPrintSettings(
+    const PrintData& data, nsIPrintSettings* settings) {
+  nsCOMPtr<nsPrintSettingsGTK> settingsGTK(do_QueryInterface(settings));
+  NS_ENSURE_STATE(settingsGTK);
+
+  nsresult rv =
+      nsPrintSettingsService::DeserializeToPrintSettings(data, settings);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Instead of re-using the GtkPrintSettings that nsIPrintSettings is
+  // wrapping, we'll create a new one to deserialize to and replace it
+  // within nsIPrintSettings.
+  GtkPrintSettings* newGtkPrintSettings = gtk_print_settings_new();
+
+  for (uint32_t i = 0; i < data.GTKPrintSettings().Length(); ++i) {
+    CStringKeyValue pair = data.GTKPrintSettings()[i];
+    gtk_print_settings_set(newGtkPrintSettings, pair.key().get(),
+                           pair.value().get());
+  }
+
+  settingsGTK->SetGtkPrintSettings(newGtkPrintSettings);
+
+  // nsPrintSettingsGTK is holding a reference to newGtkPrintSettings
+  g_object_unref(newGtkPrintSettings);
+  newGtkPrintSettings = nullptr;
+  return NS_OK;
+}
+
+nsresult nsPrintSettingsServiceGTK::_CreatePrintSettings(
+    nsIPrintSettings** _retval) {
+  *_retval = nullptr;
+  nsPrintSettingsGTK* printSettings =
+      new nsPrintSettingsGTK();  // does not initially ref count
+  NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
+
+  NS_ADDREF(*_retval = printSettings);  // ref count
+
+  return NS_OK;
+}
diff --git a/widget/gtk/nsPrintSettingsServiceGTK.h b/widget/gtk/nsPrintSettingsServiceGTK.h
new file mode 100644
index 0000000000..d26f543110
--- /dev/null
+++ b/widget/gtk/nsPrintSettingsServiceGTK.h
@@ -0,0 +1,33 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsPrintSettingsServiceGTK_h
+#define nsPrintSettingsServiceGTK_h
+
+#include "nsPrintSettingsService.h"
+
+namespace mozilla {
+namespace embedding {
+class PrintData;
+}  // namespace embedding
+}  // namespace mozilla
+
+class nsPrintSettingsServiceGTK final : public nsPrintSettingsService {
+ public:
+  nsPrintSettingsServiceGTK() = default;
+
+  NS_IMETHODIMP SerializeToPrintData(
+      nsIPrintSettings* aSettings,
+      mozilla::embedding::PrintData* data) override;
+
+  NS_IMETHODIMP DeserializeToPrintSettings(
+      const mozilla::embedding::PrintData& data,
+      nsIPrintSettings* settings) override;
+
+  virtual nsresult _CreatePrintSettings(nsIPrintSettings** _retval) override;
+};
+
+#endif  // nsPrintSettingsServiceGTK_h
diff --git a/widget/gtk/nsShmImage.cpp b/widget/gtk/nsShmImage.cpp
new file mode 100644
index 0000000000..7208b7075f
--- /dev/null
+++ b/widget/gtk/nsShmImage.cpp
@@ -0,0 +1,326 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsShmImage.h"
+
+#ifdef MOZ_HAVE_SHMIMAGE
+#  include "mozilla/X11Util.h"
+#  include "mozilla/gfx/gfxVars.h"
+#  include "mozilla/ipc/SharedMemory.h"
+#  include "gfxPlatform.h"
+#  include "nsPrintfCString.h"
+#  include "nsTArray.h"
+
+#  include <dlfcn.h>
+#  include <errno.h>
+#  include <string.h>
+#  include <sys/ipc.h>
+#  include <sys/shm.h>
+
+extern "C" {
+#  include <X11/ImUtil.h>
+}
+
+using namespace mozilla::ipc;
+using namespace mozilla::gfx;
+
+nsShmImage::nsShmImage(Display* aDisplay, Drawable aWindow, Visual* aVisual,
+                       unsigned int aDepth)
+    : mDisplay(aDisplay),
+      mConnection(XGetXCBConnection(aDisplay)),
+      mWindow(aWindow),
+      mVisual(aVisual),
+      mDepth(aDepth),
+      mFormat(mozilla::gfx::SurfaceFormat::UNKNOWN),
+      mSize(0, 0),
+      mStride(0),
+      mPixmap(XCB_NONE),
+      mGC(XCB_NONE),
+      mRequestPending(false),
+      mShmSeg(XCB_NONE),
+      mShmId(-1),
+      mShmAddr(nullptr) {
+  mozilla::PodZero(&mSyncRequest);
+}
+
+nsShmImage::~nsShmImage() { DestroyImage(); }
+
+// If XShm isn't available to our client, we'll try XShm once, fail,
+// set this to false and then never try again.
+static bool gShmAvailable = true;
+bool nsShmImage::UseShm() { return gShmAvailable; }
+
+bool nsShmImage::CreateShmSegment() {
+  size_t size = SharedMemory::PageAlignedSize(mStride * mSize.height);
+
+#  if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
+  static mozilla::LazyLogModule sPledgeLog("SandboxPledge");
+  MOZ_LOG(sPledgeLog, mozilla::LogLevel::Debug,
+          ("%s called when pledged, returning false\n", __func__));
+  return false;
+#  endif
+  mShmId = shmget(IPC_PRIVATE, size, IPC_CREAT | 0600);
+  if (mShmId == -1) {
+    return false;
+  }
+  mShmAddr = (uint8_t*)shmat(mShmId, nullptr, 0);
+  mShmSeg = xcb_generate_id(mConnection);
+
+  // Mark the handle removed so that it will destroy the segment when unmapped.
+  shmctl(mShmId, IPC_RMID, nullptr);
+
+  if (mShmAddr == (void*)-1) {
+    // Since mapping failed, the segment is already destroyed.
+    mShmId = -1;
+
+    nsPrintfCString warning("shmat(): %s (%d)\n", strerror(errno), errno);
+    NS_WARNING(warning.get());
+    return false;
+  }
+
+#  ifdef DEBUG
+  struct shmid_ds info;
+  if (shmctl(mShmId, IPC_STAT, &info) < 0) {
+    return false;
+  }
+
+  MOZ_ASSERT(size <= info.shm_segsz, "Segment doesn't have enough space!");
+#  endif
+
+  return true;
+}
+
+void nsShmImage::DestroyShmSegment() {
+  if (mShmId != -1) {
+    shmdt(mShmAddr);
+    mShmId = -1;
+  }
+}
+
+static bool gShmInitialized = false;
+static bool gUseShmPixmaps = false;
+
+bool nsShmImage::InitExtension() {
+  if (gShmInitialized) {
+    return gShmAvailable;
+  }
+
+  gShmInitialized = true;
+
+  // Bugs 1397918, 1293474 - race condition in libxcb fixed upstream as of
+  // version 1.11. Since we can't query libxcb's version directly, the only
+  // other option is to check for symbols that were added after 1.11.
+  // xcb_discard_reply64 was added in 1.11.1, so check for existence of
+  // that to verify we are using a version of libxcb with the bug fixed.
+  // Otherwise, we can't risk using libxcb due to aforementioned crashes.
+  if (!dlsym(RTLD_DEFAULT, "xcb_discard_reply64")) {
+    gShmAvailable = false;
+    return false;
+  }
+
+  const xcb_query_extension_reply_t* extReply;
+  extReply = xcb_get_extension_data(mConnection, &xcb_shm_id);
+  if (!extReply || !extReply->present) {
+    gShmAvailable = false;
+    return false;
+  }
+
+  xcb_shm_query_version_reply_t* shmReply = xcb_shm_query_version_reply(
+      mConnection, xcb_shm_query_version(mConnection), nullptr);
+
+  if (!shmReply) {
+    gShmAvailable = false;
+    return false;
+  }
+
+  gUseShmPixmaps = shmReply->shared_pixmaps &&
+                   shmReply->pixmap_format == XCB_IMAGE_FORMAT_Z_PIXMAP;
+
+  free(shmReply);
+
+  return true;
+}
+
+bool nsShmImage::CreateImage(const IntSize& aSize) {
+  MOZ_ASSERT(mConnection && mVisual);
+
+  if (!InitExtension()) {
+    return false;
+  }
+
+  mSize = aSize;
+
+  BackendType backend = gfxVars::ContentBackend();
+
+  mFormat = SurfaceFormat::UNKNOWN;
+  switch (mDepth) {
+    case 32:
+      if (mVisual->red_mask == 0xff0000 && mVisual->green_mask == 0xff00 &&
+          mVisual->blue_mask == 0xff) {
+        mFormat = SurfaceFormat::B8G8R8A8;
+      }
+      break;
+    case 24:
+      // Only support the BGRX layout, and report it as BGRA to the compositor.
+      // The alpha channel will be discarded when we put the image.
+      // Cairo/pixman lacks some fast paths for compositing BGRX onto BGRA, so
+      // just report it as BGRX directly in that case.
+      if (mVisual->red_mask == 0xff0000 && mVisual->green_mask == 0xff00 &&
+          mVisual->blue_mask == 0xff) {
+        mFormat = backend == BackendType::CAIRO ? SurfaceFormat::B8G8R8X8
+                                                : SurfaceFormat::B8G8R8A8;
+      }
+      break;
+    case 16:
+      if (mVisual->red_mask == 0xf800 && mVisual->green_mask == 0x07e0 &&
+          mVisual->blue_mask == 0x1f) {
+        mFormat = SurfaceFormat::R5G6B5_UINT16;
+      }
+      break;
+  }
+
+  if (mFormat == SurfaceFormat::UNKNOWN) {
+    NS_WARNING("Unsupported XShm Image format!");
+    gShmAvailable = false;
+    return false;
+  }
+
+  // Round up stride to the display's scanline pad (in bits) as XShm expects.
+  int scanlinePad = _XGetScanlinePad(mDisplay, mDepth);
+  int bitsPerPixel = _XGetBitsPerPixel(mDisplay, mDepth);
+  int bitsPerLine =
+      ((bitsPerPixel * aSize.width + scanlinePad - 1) / scanlinePad) *
+      scanlinePad;
+  mStride = bitsPerLine / 8;
+
+  if (!CreateShmSegment()) {
+    DestroyImage();
+    return false;
+  }
+
+  xcb_generic_error_t* error;
+  xcb_void_cookie_t cookie;
+
+  cookie = xcb_shm_attach_checked(mConnection, mShmSeg, mShmId, 0);
+
+  if ((error = xcb_request_check(mConnection, cookie))) {
+    NS_WARNING("Failed to attach MIT-SHM segment.");
+    DestroyImage();
+    gShmAvailable = false;
+    free(error);
+    return false;
+  }
+
+  if (gUseShmPixmaps) {
+    mPixmap = xcb_generate_id(mConnection);
+    cookie = xcb_shm_create_pixmap_checked(mConnection, mPixmap, mWindow,
+                                           aSize.width, aSize.height, mDepth,
+                                           mShmSeg, 0);
+
+    if ((error = xcb_request_check(mConnection, cookie))) {
+      // Disable shared pixmaps permanently if creation failed.
+      mPixmap = XCB_NONE;
+      gUseShmPixmaps = false;
+      free(error);
+    }
+  }
+
+  return true;
+}
+
+void nsShmImage::DestroyImage() {
+  if (mGC) {
+    xcb_free_gc(mConnection, mGC);
+    mGC = XCB_NONE;
+  }
+  if (mPixmap != XCB_NONE) {
+    xcb_free_pixmap(mConnection, mPixmap);
+    mPixmap = XCB_NONE;
+  }
+  if (mShmSeg != XCB_NONE) {
+    xcb_shm_detach_checked(mConnection, mShmSeg);
+    mShmSeg = XCB_NONE;
+  }
+  DestroyShmSegment();
+  // Avoid leaking any pending reply.  No real need to wait but CentOS 6 build
+  // machines don't have xcb_discard_reply().
+  WaitIfPendingReply();
+}
+
+// Wait for any in-flight shm-affected requests to complete.
+// Typically X clients would wait for a XShmCompletionEvent to be received,
+// but this works as it's sent immediately after the request is sent.
+void nsShmImage::WaitIfPendingReply() {
+  if (mRequestPending) {
+    xcb_get_input_focus_reply_t* reply =
+        xcb_get_input_focus_reply(mConnection, mSyncRequest, nullptr);
+    free(reply);
+    mRequestPending = false;
+  }
+}
+
+already_AddRefed<DrawTarget> nsShmImage::CreateDrawTarget(
+    const mozilla::LayoutDeviceIntRegion& aRegion) {
+  WaitIfPendingReply();
+
+  // Due to bug 1205045, we must avoid making GTK calls off the main thread to
+  // query window size. Instead we just track the largest offset within the
+  // image we are drawing to and grow the image to accomodate it. Since usually
+  // the entire window is invalidated on the first paint to it, this should grow
+  // the image to the necessary size quickly without many intermediate
+  // reallocations.
+  IntRect bounds = aRegion.GetBounds().ToUnknownRect();
+  IntSize size(bounds.XMost(), bounds.YMost());
+  if (size.width > mSize.width || size.height > mSize.height) {
+    DestroyImage();
+    if (!CreateImage(size)) {
+      return nullptr;
+    }
+  }
+
+  return gfxPlatform::CreateDrawTargetForData(
+      reinterpret_cast<unsigned char*>(mShmAddr) + bounds.y * mStride +
+          bounds.x * BytesPerPixel(mFormat),
+      bounds.Size(), mStride, mFormat);
+}
+
+void nsShmImage::Put(const mozilla::LayoutDeviceIntRegion& aRegion) {
+  AutoTArray<xcb_rectangle_t, 32> xrects;
+  xrects.SetCapacity(aRegion.GetNumRects());
+
+  for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
+    const mozilla::LayoutDeviceIntRect& r = iter.Get();
+    xcb_rectangle_t xrect = {(short)r.x, (short)r.y, (unsigned short)r.width,
+                             (unsigned short)r.height};
+    xrects.AppendElement(xrect);
+  }
+
+  if (!mGC) {
+    mGC = xcb_generate_id(mConnection);
+    xcb_create_gc(mConnection, mGC, mWindow, 0, nullptr);
+  }
+
+  xcb_set_clip_rectangles(mConnection, XCB_CLIP_ORDERING_YX_BANDED, mGC, 0, 0,
+                          xrects.Length(), xrects.Elements());
+
+  if (mPixmap != XCB_NONE) {
+    xcb_copy_area(mConnection, mPixmap, mWindow, mGC, 0, 0, 0, 0, mSize.width,
+                  mSize.height);
+  } else {
+    xcb_shm_put_image(mConnection, mWindow, mGC, mSize.width, mSize.height, 0,
+                      0, mSize.width, mSize.height, 0, 0, mDepth,
+                      XCB_IMAGE_FORMAT_Z_PIXMAP, 0, mShmSeg, 0);
+  }
+
+  // Send a request that returns a response so that we don't have to start a
+  // sync in nsShmImage::CreateDrawTarget.
+  mSyncRequest = xcb_get_input_focus(mConnection);
+  mRequestPending = true;
+
+  xcb_flush(mConnection);
+}
+
+#endif  // MOZ_HAVE_SHMIMAGE
diff --git a/widget/gtk/nsShmImage.h b/widget/gtk/nsShmImage.h
new file mode 100644
index 0000000000..2d92c39e0d
--- /dev/null
+++ b/widget/gtk/nsShmImage.h
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __mozilla_widget_nsShmImage_h__
+#define __mozilla_widget_nsShmImage_h__
+
+#if defined(MOZ_X11)
+#  define MOZ_HAVE_SHMIMAGE
+#endif
+
+#ifdef MOZ_HAVE_SHMIMAGE
+
+#  include "mozilla/gfx/2D.h"
+#  include "nsIWidget.h"
+#  include "Units.h"
+
+#  include <X11/Xlib-xcb.h>
+#  include <xcb/shm.h>
+
+class nsShmImage {
+  // bug 1168843, compositor thread may create shared memory instances that are
+  // destroyed by main thread on shutdown, so this must use thread-safe RC to
+  // avoid hitting assertion
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsShmImage)
+
+ public:
+  static bool UseShm();
+
+  already_AddRefed<mozilla::gfx::DrawTarget> CreateDrawTarget(
+      const mozilla::LayoutDeviceIntRegion& aRegion);
+
+  void Put(const mozilla::LayoutDeviceIntRegion& aRegion);
+
+  nsShmImage(Display* aDisplay, Drawable aWindow, Visual* aVisual,
+             unsigned int aDepth);
+
+ private:
+  ~nsShmImage();
+
+  bool InitExtension();
+
+  bool CreateShmSegment();
+  void DestroyShmSegment();
+
+  bool CreateImage(const mozilla::gfx::IntSize& aSize);
+  void DestroyImage();
+
+  void WaitIfPendingReply();
+
+  Display* mDisplay;
+  xcb_connection_t* mConnection;
+  Window mWindow;
+  Visual* mVisual;
+  unsigned int mDepth;
+
+  mozilla::gfx::SurfaceFormat mFormat;
+  mozilla::gfx::IntSize mSize;
+  int mStride;
+
+  xcb_pixmap_t mPixmap;
+  xcb_gcontext_t mGC;
+  xcb_get_input_focus_cookie_t mSyncRequest;
+  bool mRequestPending;
+
+  xcb_shm_seg_t mShmSeg;
+  int mShmId;
+  uint8_t* mShmAddr;
+};
+
+#endif  // MOZ_HAVE_SHMIMAGE
+
+#endif
diff --git a/widget/gtk/nsSound.cpp b/widget/gtk/nsSound.cpp
new file mode 100644
index 0000000000..4d685d8566
--- /dev/null
+++ b/widget/gtk/nsSound.cpp
@@ -0,0 +1,398 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string.h>
+
+#include "nscore.h"
+#include "plstr.h"
+#include "prlink.h"
+
+#include "nsSound.h"
+
+#include "HeadlessSound.h"
+#include "nsIURL.h"
+#include "nsNetUtil.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsDirectoryService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/Unused.h"
+#include "mozilla/WidgetUtils.h"
+#include "nsIXULAppInfo.h"
+#include "nsContentUtils.h"
+#include "gfxPlatform.h"
+#include "mozilla/ClearOnShutdown.h"
+
+#include <stdio.h>
+#include <unistd.h>
+
+#include <gtk/gtk.h>
+static PRLibrary* libcanberra = nullptr;
+
+/* used to play sounds with libcanberra. */
+typedef struct _ca_context ca_context;
+typedef struct _ca_proplist ca_proplist;
+
+typedef void (*ca_finish_callback_t)(ca_context* c, uint32_t id, int error_code,
+                                     void* userdata);
+
+typedef int (*ca_context_create_fn)(ca_context**);
+typedef int (*ca_context_destroy_fn)(ca_context*);
+typedef int (*ca_context_play_fn)(ca_context* c, uint32_t id, ...);
+typedef int (*ca_context_change_props_fn)(ca_context* c, ...);
+typedef int (*ca_proplist_create_fn)(ca_proplist**);
+typedef int (*ca_proplist_destroy_fn)(ca_proplist*);
+typedef int (*ca_proplist_sets_fn)(ca_proplist* c, const char* key,
+                                   const char* value);
+typedef int (*ca_context_play_full_fn)(ca_context* c, uint32_t id,
+                                       ca_proplist* p, ca_finish_callback_t cb,
+                                       void* userdata);
+
+static ca_context_create_fn ca_context_create;
+static ca_context_destroy_fn ca_context_destroy;
+static ca_context_play_fn ca_context_play;
+static ca_context_change_props_fn ca_context_change_props;
+static ca_proplist_create_fn ca_proplist_create;
+static ca_proplist_destroy_fn ca_proplist_destroy;
+static ca_proplist_sets_fn ca_proplist_sets;
+static ca_context_play_full_fn ca_context_play_full;
+
+struct ScopedCanberraFile {
+  explicit ScopedCanberraFile(nsIFile* file) : mFile(file){};
+
+  ~ScopedCanberraFile() {
+    if (mFile) {
+      mFile->Remove(false);
+    }
+  }
+
+  void forget() { mozilla::Unused << mFile.forget(); }
+  nsIFile* operator->() { return mFile; }
+  operator nsIFile*() { return mFile; }
+
+  nsCOMPtr<nsIFile> mFile;
+};
+
+static ca_context* ca_context_get_default() {
+  // This allows us to avoid race conditions with freeing the context by handing
+  // that responsibility to Glib, and still use one context at a time
+  static GPrivate ctx_private =
+      G_PRIVATE_INIT((GDestroyNotify)ca_context_destroy);
+
+  ca_context* ctx = (ca_context*)g_private_get(&ctx_private);
+
+  if (ctx) {
+    return ctx;
+  }
+
+  ca_context_create(&ctx);
+  if (!ctx) {
+    return nullptr;
+  }
+
+  g_private_set(&ctx_private, ctx);
+
+  GtkSettings* settings = gtk_settings_get_default();
+  if (g_object_class_find_property(G_OBJECT_GET_CLASS(settings),
+                                   "gtk-sound-theme-name")) {
+    gchar* sound_theme_name = nullptr;
+    g_object_get(settings, "gtk-sound-theme-name", &sound_theme_name, nullptr);
+
+    if (sound_theme_name) {
+      ca_context_change_props(ctx, "canberra.xdg-theme.name", sound_theme_name,
+                              nullptr);
+      g_free(sound_theme_name);
+    }
+  }
+
+  nsAutoString wbrand;
+  mozilla::widget::WidgetUtils::GetBrandShortName(wbrand);
+  ca_context_change_props(ctx, "application.name",
+                          NS_ConvertUTF16toUTF8(wbrand).get(), nullptr);
+
+  nsCOMPtr<nsIXULAppInfo> appInfo =
+      do_GetService("@mozilla.org/xre/app-info;1");
+  if (appInfo) {
+    nsAutoCString version;
+    appInfo->GetVersion(version);
+
+    ca_context_change_props(ctx, "application.version", version.get(), nullptr);
+  }
+
+  ca_context_change_props(ctx, "application.icon_name", MOZ_APP_NAME, nullptr);
+
+  return ctx;
+}
+
+static void ca_finish_cb(ca_context* c, uint32_t id, int error_code,
+                         void* userdata) {
+  nsIFile* file = reinterpret_cast<nsIFile*>(userdata);
+  if (file) {
+    file->Remove(false);
+    NS_RELEASE(file);
+  }
+}
+
+NS_IMPL_ISUPPORTS(nsSound, nsISound, nsIStreamLoaderObserver)
+
+////////////////////////////////////////////////////////////////////////
+nsSound::nsSound() { mInited = false; }
+
+nsSound::~nsSound() = default;
+
+NS_IMETHODIMP
+nsSound::Init() {
+  // This function is designed so that no library is compulsory, and
+  // one library missing doesn't cause the other(s) to not be used.
+  if (mInited) return NS_OK;
+
+  mInited = true;
+
+  if (!libcanberra) {
+    libcanberra = PR_LoadLibrary("libcanberra.so.0");
+    if (libcanberra) {
+      ca_context_create = (ca_context_create_fn)PR_FindFunctionSymbol(
+          libcanberra, "ca_context_create");
+      if (!ca_context_create) {
+#ifdef MOZ_TSAN
+        // With TSan, we cannot unload libcanberra once we have loaded it
+        // because TSan does not support unloading libraries that are matched
+        // from its suppression list. Hence we just keep the library loaded in
+        // TSan builds.
+        libcanberra = nullptr;
+        return NS_OK;
+#endif
+        PR_UnloadLibrary(libcanberra);
+        libcanberra = nullptr;
+      } else {
+        // at this point we know we have a good libcanberra library
+        ca_context_destroy = (ca_context_destroy_fn)PR_FindFunctionSymbol(
+            libcanberra, "ca_context_destroy");
+        ca_context_play = (ca_context_play_fn)PR_FindFunctionSymbol(
+            libcanberra, "ca_context_play");
+        ca_context_change_props =
+            (ca_context_change_props_fn)PR_FindFunctionSymbol(
+                libcanberra, "ca_context_change_props");
+        ca_proplist_create = (ca_proplist_create_fn)PR_FindFunctionSymbol(
+            libcanberra, "ca_proplist_create");
+        ca_proplist_destroy = (ca_proplist_destroy_fn)PR_FindFunctionSymbol(
+            libcanberra, "ca_proplist_destroy");
+        ca_proplist_sets = (ca_proplist_sets_fn)PR_FindFunctionSymbol(
+            libcanberra, "ca_proplist_sets");
+        ca_context_play_full = (ca_context_play_full_fn)PR_FindFunctionSymbol(
+            libcanberra, "ca_context_play_full");
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+/* static */
+void nsSound::Shutdown() {
+#ifndef MOZ_TSAN
+  if (libcanberra) {
+    PR_UnloadLibrary(libcanberra);
+    libcanberra = nullptr;
+  }
+#endif
+}
+
+namespace mozilla {
+namespace sound {
+StaticRefPtr<nsISound> sInstance;
+}
+}  // namespace mozilla
+/* static */
+already_AddRefed<nsISound> nsSound::GetInstance() {
+  using namespace mozilla::sound;
+
+  if (!sInstance) {
+    if (gfxPlatform::IsHeadless()) {
+      sInstance = new mozilla::widget::HeadlessSound();
+    } else {
+      sInstance = new nsSound();
+    }
+    ClearOnShutdown(&sInstance);
+  }
+
+  RefPtr<nsISound> service = sInstance.get();
+  return service.forget();
+}
+
+NS_IMETHODIMP nsSound::OnStreamComplete(nsIStreamLoader* aLoader,
+                                        nsISupports* context, nsresult aStatus,
+                                        uint32_t dataLen, const uint8_t* data) {
+  // print a load error on bad status, and return
+  if (NS_FAILED(aStatus)) {
+#ifdef DEBUG
+    if (aLoader) {
+      nsCOMPtr<nsIRequest> request;
+      aLoader->GetRequest(getter_AddRefs(request));
+      if (request) {
+        nsCOMPtr<nsIURI> uri;
+        nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
+        if (channel) {
+          channel->GetURI(getter_AddRefs(uri));
+          if (uri) {
+            printf("Failed to load %s\n", uri->GetSpecOrDefault().get());
+          }
+        }
+      }
+    }
+#endif
+    return aStatus;
+  }
+
+  nsCOMPtr<nsIFile> tmpFile;
+  nsDirectoryService::gService->Get(NS_OS_TEMP_DIR, NS_GET_IID(nsIFile),
+                                    getter_AddRefs(tmpFile));
+
+  nsresult rv =
+      tmpFile->AppendNative(nsDependentCString("mozilla_audio_sample"));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, PR_IRUSR | PR_IWUSR);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  ScopedCanberraFile canberraFile(tmpFile);
+
+  mozilla::AutoFDClose fd;
+  rv = canberraFile->OpenNSPRFileDesc(PR_WRONLY, PR_IRUSR | PR_IWUSR,
+                                      &fd.rwget());
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  // XXX: Should we do this on another thread?
+  uint32_t length = dataLen;
+  while (length > 0) {
+    int32_t amount = PR_Write(fd, data, length);
+    if (amount < 0) {
+      return NS_ERROR_FAILURE;
+    }
+    length -= amount;
+    data += amount;
+  }
+
+  ca_context* ctx = ca_context_get_default();
+  if (!ctx) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  ca_proplist* p;
+  ca_proplist_create(&p);
+  if (!p) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  nsAutoCString path;
+  rv = canberraFile->GetNativePath(path);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  ca_proplist_sets(p, "media.filename", path.get());
+  if (ca_context_play_full(ctx, 0, p, ca_finish_cb, canberraFile) >= 0) {
+    // Don't delete the temporary file here if ca_context_play_full succeeds
+    canberraFile.forget();
+  }
+  ca_proplist_destroy(p);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSound::Beep() {
+  ::gdk_beep();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSound::Play(nsIURL* aURL) {
+  if (!mInited) Init();
+
+  if (!libcanberra) return NS_ERROR_NOT_AVAILABLE;
+
+  nsresult rv;
+  if (aURL->SchemeIs("file")) {
+    ca_context* ctx = ca_context_get_default();
+    if (!ctx) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    nsAutoCString spec;
+    rv = aURL->GetSpec(spec);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    gchar* path = g_filename_from_uri(spec.get(), nullptr, nullptr);
+    if (!path) {
+      return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+    }
+
+    ca_context_play(ctx, 0, "media.filename", path, nullptr);
+    g_free(path);
+  } else {
+    nsCOMPtr<nsIStreamLoader> loader;
+    rv = NS_NewStreamLoader(
+        getter_AddRefs(loader), aURL,
+        this,  // aObserver
+        nsContentUtils::GetSystemPrincipal(),
+        nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+        nsIContentPolicy::TYPE_OTHER);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsSound::PlayEventSound(uint32_t aEventId) {
+  if (!mInited) Init();
+
+  if (!libcanberra) return NS_OK;
+
+  // Do we even want alert sounds?
+  GtkSettings* settings = gtk_settings_get_default();
+
+  if (g_object_class_find_property(G_OBJECT_GET_CLASS(settings),
+                                   "gtk-enable-event-sounds")) {
+    gboolean enable_sounds = TRUE;
+    g_object_get(settings, "gtk-enable-event-sounds", &enable_sounds, nullptr);
+
+    if (!enable_sounds) {
+      return NS_OK;
+    }
+  }
+
+  ca_context* ctx = ca_context_get_default();
+  if (!ctx) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  switch (aEventId) {
+    case EVENT_ALERT_DIALOG_OPEN:
+      ca_context_play(ctx, 0, "event.id", "dialog-warning", nullptr);
+      break;
+    case EVENT_CONFIRM_DIALOG_OPEN:
+      ca_context_play(ctx, 0, "event.id", "dialog-question", nullptr);
+      break;
+    case EVENT_NEW_MAIL_RECEIVED:
+      ca_context_play(ctx, 0, "event.id", "message-new-email", nullptr);
+      break;
+    case EVENT_MENU_EXECUTE:
+      ca_context_play(ctx, 0, "event.id", "menu-click", nullptr);
+      break;
+    case EVENT_MENU_POPUP:
+      ca_context_play(ctx, 0, "event.id", "menu-popup", nullptr);
+      break;
+  }
+  return NS_OK;
+}
diff --git a/widget/gtk/nsSound.h b/widget/gtk/nsSound.h
new file mode 100644
index 0000000000..8f4fe5a04b
--- /dev/null
+++ b/widget/gtk/nsSound.h
@@ -0,0 +1,33 @@
+/* -*- 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 __nsSound_h__
+#define __nsSound_h__
+
+#include "nsISound.h"
+#include "nsIStreamLoader.h"
+
+#include <gtk/gtk.h>
+
+class nsSound : public nsISound, public nsIStreamLoaderObserver {
+ public:
+  nsSound();
+
+  static void Shutdown();
+  static already_AddRefed<nsISound> GetInstance();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSISOUND
+  NS_DECL_NSISTREAMLOADEROBSERVER
+
+ private:
+  virtual ~nsSound();
+
+  bool mInited;
+};
+
+#endif /* __nsSound_h__ */
diff --git a/widget/gtk/nsToolkit.cpp b/widget/gtk/nsToolkit.cpp
new file mode 100644
index 0000000000..aaf13239e0
--- /dev/null
+++ b/widget/gtk/nsToolkit.cpp
@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nscore.h"  // needed for 'nullptr'
+#include "nsGTKToolkit.h"
+
+nsGTKToolkit* nsGTKToolkit::gToolkit = nullptr;
+
+//-------------------------------------------------------------------------------
+// Return the toolkit. If a toolkit does not yet exist, then one will be
+// created.
+//-------------------------------------------------------------------------------
+// static
+nsGTKToolkit* nsGTKToolkit::GetToolkit() {
+  if (!gToolkit) {
+    gToolkit = new nsGTKToolkit();
+  }
+
+  return gToolkit;
+}
diff --git a/widget/gtk/nsUserIdleServiceGTK.cpp b/widget/gtk/nsUserIdleServiceGTK.cpp
new file mode 100644
index 0000000000..37fe8d1bd4
--- /dev/null
+++ b/widget/gtk/nsUserIdleServiceGTK.cpp
@@ -0,0 +1,127 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <gtk/gtk.h>
+
+#include "nsUserIdleServiceGTK.h"
+#include "nsDebug.h"
+#include "prlink.h"
+#include "mozilla/Logging.h"
+#include "WidgetUtilsGtk.h"
+
+using mozilla::LogLevel;
+
+static mozilla::LazyLogModule sIdleLog("nsIUserIdleService");
+
+#ifdef MOZ_X11
+typedef bool (*_XScreenSaverQueryExtension_fn)(Display* dpy, int* event_base,
+                                               int* error_base);
+
+typedef XScreenSaverInfo* (*_XScreenSaverAllocInfo_fn)(void);
+
+typedef void (*_XScreenSaverQueryInfo_fn)(Display* dpy, Drawable drw,
+                                          XScreenSaverInfo* info);
+
+static _XScreenSaverQueryExtension_fn _XSSQueryExtension = nullptr;
+static _XScreenSaverAllocInfo_fn _XSSAllocInfo = nullptr;
+static _XScreenSaverQueryInfo_fn _XSSQueryInfo = nullptr;
+#endif
+static bool sInitialized = false;
+
+static void Initialize() {
+#ifdef MOZ_X11
+  if (!mozilla::widget::GdkIsX11Display()) {
+    return;
+  }
+
+  // This will leak - See comments in ~nsUserIdleServiceGTK().
+  PRLibrary* xsslib = PR_LoadLibrary("libXss.so.1");
+  if (!xsslib)  // ouch.
+  {
+    MOZ_LOG(sIdleLog, LogLevel::Warning, ("Failed to find libXss.so!\n"));
+    return;
+  }
+
+  _XSSQueryExtension = (_XScreenSaverQueryExtension_fn)PR_FindFunctionSymbol(
+      xsslib, "XScreenSaverQueryExtension");
+  _XSSAllocInfo = (_XScreenSaverAllocInfo_fn)PR_FindFunctionSymbol(
+      xsslib, "XScreenSaverAllocInfo");
+  _XSSQueryInfo = (_XScreenSaverQueryInfo_fn)PR_FindFunctionSymbol(
+      xsslib, "XScreenSaverQueryInfo");
+
+  if (!_XSSQueryExtension)
+    MOZ_LOG(sIdleLog, LogLevel::Warning,
+            ("Failed to get XSSQueryExtension!\n"));
+  if (!_XSSAllocInfo)
+    MOZ_LOG(sIdleLog, LogLevel::Warning, ("Failed to get XSSAllocInfo!\n"));
+  if (!_XSSQueryInfo)
+    MOZ_LOG(sIdleLog, LogLevel::Warning, ("Failed to get XSSQueryInfo!\n"));
+
+  sInitialized = true;
+#endif
+}
+
+#ifdef MOZ_X11
+nsUserIdleServiceGTK::nsUserIdleServiceGTK() : mXssInfo(nullptr) {
+#else
+nsUserIdleServiceGTK::nsUserIdleServiceGTK() {
+#endif
+  Initialize();
+}
+
+nsUserIdleServiceGTK::~nsUserIdleServiceGTK() {
+#ifdef MOZ_X11
+  if (mXssInfo) XFree(mXssInfo);
+#endif
+
+// It is not safe to unload libXScrnSaver until each display is closed because
+// the library registers callbacks through XESetCloseDisplay (Bug 397607).
+// (Also the library and its functions are scoped for the file not the object.)
+#if 0
+    if (xsslib) {
+        PR_UnloadLibrary(xsslib);
+        xsslib = nullptr;
+    }
+#endif
+}
+
+bool nsUserIdleServiceGTK::PollIdleTime(uint32_t* aIdleTime) {
+#ifdef MOZ_X11
+  if (!sInitialized) {
+    // For some reason, we could not find xscreensaver.
+    return false;
+  }
+
+  // Ask xscreensaver about idle time:
+  *aIdleTime = 0;
+
+  // We might not have a display (cf. in xpcshell)
+  Display* dplay = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+  if (!dplay) {
+    MOZ_LOG(sIdleLog, LogLevel::Warning, ("No display found!\n"));
+    return false;
+  }
+
+  if (!_XSSQueryExtension || !_XSSAllocInfo || !_XSSQueryInfo) {
+    return false;
+  }
+
+  int event_base, error_base;
+  if (_XSSQueryExtension(dplay, &event_base, &error_base)) {
+    if (!mXssInfo) mXssInfo = _XSSAllocInfo();
+    if (!mXssInfo) return false;
+    _XSSQueryInfo(dplay, GDK_ROOT_WINDOW(), mXssInfo);
+    *aIdleTime = mXssInfo->idle;
+    return true;
+  }
+  // If we get here, we couldn't get to XScreenSaver:
+  MOZ_LOG(sIdleLog, LogLevel::Warning, ("XSSQueryExtension returned false!\n"));
+#endif
+  return false;
+}
+
+bool nsUserIdleServiceGTK::UsePollMode() { return sInitialized; }
diff --git a/widget/gtk/nsUserIdleServiceGTK.h b/widget/gtk/nsUserIdleServiceGTK.h
new file mode 100644
index 0000000000..e596283e24
--- /dev/null
+++ b/widget/gtk/nsUserIdleServiceGTK.h
@@ -0,0 +1,56 @@
+/* -*- 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 nsUserIdleServiceGTK_h__
+#define nsUserIdleServiceGTK_h__
+
+#include "nsUserIdleService.h"
+#ifdef MOZ_X11
+#  include <X11/Xlib.h>
+#  include <X11/Xutil.h>
+#  include <gdk/gdkx.h>
+#endif
+
+#ifdef MOZ_X11
+typedef struct {
+  Window window;               // Screen saver window
+  int state;                   // ScreenSaver(Off,On,Disabled)
+  int kind;                    // ScreenSaver(Blanked,Internal,External)
+  unsigned long til_or_since;  // milliseconds since/til screensaver kicks in
+  unsigned long idle;          // milliseconds idle
+  unsigned long event_mask;    // event stuff
+} XScreenSaverInfo;
+#endif
+
+class nsUserIdleServiceGTK : public nsUserIdleService {
+ public:
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(nsUserIdleServiceGTK, nsUserIdleService)
+
+  virtual bool PollIdleTime(uint32_t* aIdleTime) override;
+
+  static already_AddRefed<nsUserIdleServiceGTK> GetInstance() {
+    RefPtr<nsUserIdleServiceGTK> idleService =
+        nsUserIdleService::GetInstance().downcast<nsUserIdleServiceGTK>();
+    if (!idleService) {
+      idleService = new nsUserIdleServiceGTK();
+    }
+
+    return idleService.forget();
+  }
+
+ private:
+  ~nsUserIdleServiceGTK();
+#ifdef MOZ_X11
+  XScreenSaverInfo* mXssInfo;
+#endif
+
+ protected:
+  nsUserIdleServiceGTK();
+  virtual bool UsePollMode() override;
+};
+
+#endif  // nsUserIdleServiceGTK_h__
diff --git a/widget/gtk/nsWaylandDisplay.cpp b/widget/gtk/nsWaylandDisplay.cpp
new file mode 100644
index 0000000000..f9b574d627
--- /dev/null
+++ b/widget/gtk/nsWaylandDisplay.cpp
@@ -0,0 +1,316 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsWaylandDisplay.h"
+
+#include <dlfcn.h>
+
+#include "base/message_loop.h"  // for MessageLoop
+#include "base/task.h"          // for NewRunnableMethod, etc
+#include "mozilla/StaticMutex.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "WidgetUtilsGtk.h"
+
+struct _GdkSeat;
+typedef struct _GdkSeat GdkSeat;
+
+namespace mozilla {
+namespace widget {
+
+// nsWaylandDisplay needs to be created for each calling thread(main thread,
+// compositor thread and render thread)
+#define MAX_DISPLAY_CONNECTIONS 10
+
+// An array of active wayland displays. We need a display for every thread
+// where is wayland interface used as we need to dispatch waylands events
+// there.
+static RefPtr<nsWaylandDisplay> gWaylandDisplays[MAX_DISPLAY_CONNECTIONS];
+static StaticMutex gWaylandDisplayArrayWriteMutex MOZ_UNANNOTATED;
+
+// Dispatch events to Compositor/Render queues
+void WaylandDispatchDisplays() {
+  MOZ_ASSERT(NS_IsMainThread(),
+             "WaylandDispatchDisplays() is supposed to run in main thread");
+  for (auto& display : gWaylandDisplays) {
+    if (display) {
+      display->DispatchEventQueue();
+    }
+  }
+}
+
+void WaylandDisplayRelease() {
+  StaticMutexAutoLock lock(gWaylandDisplayArrayWriteMutex);
+  for (auto& display : gWaylandDisplays) {
+    if (display) {
+      display = nullptr;
+    }
+  }
+}
+
+// Get WaylandDisplay for given wl_display and actual calling thread.
+RefPtr<nsWaylandDisplay> WaylandDisplayGet(GdkDisplay* aGdkDisplay) {
+  wl_display* waylandDisplay = WaylandDisplayGetWLDisplay(aGdkDisplay);
+  if (!waylandDisplay) {
+    return nullptr;
+  }
+
+  // Search existing display connections for wl_display:thread combination.
+  for (auto& display : gWaylandDisplays) {
+    if (display && display->Matches(waylandDisplay)) {
+      return display;
+    }
+  }
+
+  StaticMutexAutoLock arrayLock(gWaylandDisplayArrayWriteMutex);
+  for (auto& display : gWaylandDisplays) {
+    if (display == nullptr) {
+      display = new nsWaylandDisplay(waylandDisplay);
+      return display;
+    }
+  }
+
+  MOZ_CRASH("There's too many wayland display conections!");
+  return nullptr;
+}
+
+wl_display* WaylandDisplayGetWLDisplay(GdkDisplay* aGdkDisplay) {
+  if (!aGdkDisplay) {
+    aGdkDisplay = gdk_display_get_default();
+    if (!GdkIsWaylandDisplay(aGdkDisplay)) {
+      return nullptr;
+    }
+  }
+
+  return gdk_wayland_display_get_wl_display(aGdkDisplay);
+}
+
+void nsWaylandDisplay::SetShm(wl_shm* aShm) { mShm = aShm; }
+
+void nsWaylandDisplay::SetCompositor(wl_compositor* aCompositor) {
+  mCompositor = aCompositor;
+}
+
+void nsWaylandDisplay::SetSubcompositor(wl_subcompositor* aSubcompositor) {
+  mSubcompositor = aSubcompositor;
+}
+
+void nsWaylandDisplay::SetIdleInhibitManager(
+    zwp_idle_inhibit_manager_v1* aIdleInhibitManager) {
+  mIdleInhibitManager = aIdleInhibitManager;
+}
+
+void nsWaylandDisplay::SetViewporter(wp_viewporter* aViewporter) {
+  mViewporter = aViewporter;
+}
+
+void nsWaylandDisplay::SetRelativePointerManager(
+    zwp_relative_pointer_manager_v1* aRelativePointerManager) {
+  mRelativePointerManager = aRelativePointerManager;
+}
+
+void nsWaylandDisplay::SetPointerConstraints(
+    zwp_pointer_constraints_v1* aPointerConstraints) {
+  mPointerConstraints = aPointerConstraints;
+}
+
+void nsWaylandDisplay::SetDmabuf(zwp_linux_dmabuf_v1* aDmabuf) {
+  mDmabuf = aDmabuf;
+}
+
+void nsWaylandDisplay::SetXdgActivation(xdg_activation_v1* aXdgActivation) {
+  mXdgActivation = aXdgActivation;
+}
+
+static void global_registry_handler(void* data, wl_registry* registry,
+                                    uint32_t id, const char* interface,
+                                    uint32_t version) {
+  auto* display = static_cast<nsWaylandDisplay*>(data);
+  if (!display) {
+    return;
+  }
+
+  if (strcmp(interface, "wl_shm") == 0) {
+    auto* shm = WaylandRegistryBind<wl_shm>(registry, id, &wl_shm_interface, 1);
+    wl_proxy_set_queue((struct wl_proxy*)shm, display->GetEventQueue());
+    display->SetShm(shm);
+  } else if (strcmp(interface, "zwp_idle_inhibit_manager_v1") == 0) {
+    auto* idle_inhibit_manager =
+        WaylandRegistryBind<zwp_idle_inhibit_manager_v1>(
+            registry, id, &zwp_idle_inhibit_manager_v1_interface, 1);
+    wl_proxy_set_queue((struct wl_proxy*)idle_inhibit_manager,
+                       display->GetEventQueue());
+    display->SetIdleInhibitManager(idle_inhibit_manager);
+  } else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0) {
+    auto* relative_pointer_manager =
+        WaylandRegistryBind<zwp_relative_pointer_manager_v1>(
+            registry, id, &zwp_relative_pointer_manager_v1_interface, 1);
+    wl_proxy_set_queue((struct wl_proxy*)relative_pointer_manager,
+                       display->GetEventQueue());
+    display->SetRelativePointerManager(relative_pointer_manager);
+  } else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0) {
+    auto* pointer_constraints = WaylandRegistryBind<zwp_pointer_constraints_v1>(
+        registry, id, &zwp_pointer_constraints_v1_interface, 1);
+    wl_proxy_set_queue((struct wl_proxy*)pointer_constraints,
+                       display->GetEventQueue());
+    display->SetPointerConstraints(pointer_constraints);
+  } else if (strcmp(interface, "wl_compositor") == 0) {
+    // Requested wl_compositor version 4 as we need wl_surface_damage_buffer().
+    auto* compositor = WaylandRegistryBind<wl_compositor>(
+        registry, id, &wl_compositor_interface, 4);
+    wl_proxy_set_queue((struct wl_proxy*)compositor, display->GetEventQueue());
+    display->SetCompositor(compositor);
+  } else if (strcmp(interface, "wl_subcompositor") == 0) {
+    auto* subcompositor = WaylandRegistryBind<wl_subcompositor>(
+        registry, id, &wl_subcompositor_interface, 1);
+    wl_proxy_set_queue((struct wl_proxy*)subcompositor,
+                       display->GetEventQueue());
+    display->SetSubcompositor(subcompositor);
+  } else if (strcmp(interface, "wp_viewporter") == 0) {
+    auto* viewporter = WaylandRegistryBind<wp_viewporter>(
+        registry, id, &wp_viewporter_interface, 1);
+    wl_proxy_set_queue((struct wl_proxy*)viewporter, display->GetEventQueue());
+    display->SetViewporter(viewporter);
+  } else if (strcmp(interface, "zwp_linux_dmabuf_v1") == 0 && version > 2) {
+    auto* dmabuf = WaylandRegistryBind<zwp_linux_dmabuf_v1>(
+        registry, id, &zwp_linux_dmabuf_v1_interface, 3);
+    wl_proxy_set_queue((struct wl_proxy*)dmabuf, display->GetEventQueue());
+    display->SetDmabuf(dmabuf);
+  } else if (strcmp(interface, "xdg_activation_v1") == 0) {
+    auto* activation = WaylandRegistryBind<xdg_activation_v1>(
+        registry, id, &xdg_activation_v1_interface, 1);
+    display->SetXdgActivation(activation);
+  }
+}
+
+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::DispatchEventQueue() {
+  if (mEventQueue) {
+    wl_display_dispatch_queue_pending(mDisplay, mEventQueue);
+  }
+  return true;
+}
+
+void nsWaylandDisplay::SyncEnd() {
+  wl_callback_destroy(mSyncCallback);
+  mSyncCallback = nullptr;
+}
+
+static void wayland_sync_callback(void* data, struct wl_callback* callback,
+                                  uint32_t time) {
+  auto display = static_cast<nsWaylandDisplay*>(data);
+  display->SyncEnd();
+}
+
+static const struct wl_callback_listener sync_callback_listener = {
+    .done = wayland_sync_callback};
+
+void nsWaylandDisplay::SyncBegin() {
+  WaitForSyncEnd();
+
+  // Use wl_display_sync() to synchronize wayland events.
+  // See dri2_wl_swap_buffers_with_damage() from MESA
+  // or wl_display_roundtrip_queue() from wayland-client.
+  struct wl_display* displayWrapper =
+      static_cast<wl_display*>(wl_proxy_create_wrapper((void*)mDisplay));
+  if (!displayWrapper) {
+    NS_WARNING("Failed to create wl_proxy wrapper!");
+    return;
+  }
+
+  wl_proxy_set_queue((struct wl_proxy*)displayWrapper, mEventQueue);
+  mSyncCallback = wl_display_sync(displayWrapper);
+  wl_proxy_wrapper_destroy((void*)displayWrapper);
+
+  if (!mSyncCallback) {
+    NS_WARNING("Failed to create wl_display_sync callback!");
+    return;
+  }
+
+  wl_callback_add_listener(mSyncCallback, &sync_callback_listener, this);
+  wl_display_flush(mDisplay);
+}
+
+void nsWaylandDisplay::QueueSyncBegin() {
+  RefPtr<nsWaylandDisplay> self(this);
+  NS_DispatchToMainThread(
+      NS_NewRunnableFunction("nsWaylandDisplay::QueueSyncBegin",
+                             [self]() -> void { self->SyncBegin(); }));
+}
+
+void nsWaylandDisplay::WaitForSyncEnd() {
+  MOZ_RELEASE_ASSERT(
+      NS_IsMainThread(),
+      "nsWaylandDisplay::WaitForSyncEnd() can be called in main thread only!");
+
+  // We're done here
+  if (!mSyncCallback) {
+    return;
+  }
+
+  while (mSyncCallback != nullptr) {
+    // TODO: wl_display_dispatch_queue() should not be called while
+    // glib main loop is iterated at nsAppShell::ProcessNextNativeEvent().
+    if (wl_display_dispatch_queue(mDisplay, mEventQueue) == -1) {
+      NS_WARNING("wl_display_dispatch_queue failed!");
+      SyncEnd();
+      return;
+    }
+  }
+}
+
+bool nsWaylandDisplay::Matches(wl_display* aDisplay) {
+  return mThreadId == PR_GetCurrentThread() && aDisplay == mDisplay;
+}
+
+static void WlCrashHandler(const char* format, va_list args) {
+  MOZ_CRASH_UNSAFE(g_strdup_vprintf(format, args));
+}
+
+nsWaylandDisplay::nsWaylandDisplay(wl_display* aDisplay)
+    : mThreadId(PR_GetCurrentThread()), mDisplay(aDisplay) {
+  // GTK sets the log handler on display creation, thus we overwrite it here
+  // in a similar fashion
+  wl_log_set_handler_client(WlCrashHandler);
+
+  wl_registry* registry = wl_display_get_registry(mDisplay);
+  wl_registry_add_listener(registry, &registry_listener, this);
+  if (!NS_IsMainThread()) {
+    mEventQueue = wl_display_create_queue(mDisplay);
+    wl_proxy_set_queue((struct wl_proxy*)registry, mEventQueue);
+  }
+  if (mEventQueue) {
+    wl_display_roundtrip_queue(mDisplay, mEventQueue);
+    wl_display_roundtrip_queue(mDisplay, mEventQueue);
+  } else {
+    wl_display_roundtrip(mDisplay);
+    wl_display_roundtrip(mDisplay);
+  }
+  wl_registry_destroy(registry);
+
+  // Check we have critical Wayland interfaces.
+  // Missing ones indicates a compositor bug and we can't continue.
+  MOZ_DIAGNOSTIC_ASSERT(GetShm(), "We're missing shm interface!");
+  MOZ_DIAGNOSTIC_ASSERT(GetCompositor(), "We're missing compositor interface!");
+  MOZ_DIAGNOSTIC_ASSERT(GetSubcompositor(),
+                        "We're missing subcompositor interface!");
+}
+
+nsWaylandDisplay::~nsWaylandDisplay() {
+  if (mEventQueue) {
+    wl_event_queue_destroy(mEventQueue);
+    mEventQueue = nullptr;
+  }
+  mDisplay = nullptr;
+}
+
+}  // namespace widget
+}  // namespace mozilla
diff --git a/widget/gtk/nsWaylandDisplay.h b/widget/gtk/nsWaylandDisplay.h
new file mode 100644
index 0000000000..5c0f00794b
--- /dev/null
+++ b/widget/gtk/nsWaylandDisplay.h
@@ -0,0 +1,130 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __MOZ_WAYLAND_DISPLAY_H__
+#define __MOZ_WAYLAND_DISPLAY_H__
+
+#include "DMABufLibWrapper.h"
+
+#include "mozilla/widget/mozwayland.h"
+#include "mozilla/widget/gbm.h"
+#include "mozilla/widget/idle-inhibit-unstable-v1-client-protocol.h"
+#include "mozilla/widget/relative-pointer-unstable-v1-client-protocol.h"
+#include "mozilla/widget/pointer-constraints-unstable-v1-client-protocol.h"
+#include "mozilla/widget/linux-dmabuf-unstable-v1-client-protocol.h"
+#include "mozilla/widget/viewporter-client-protocol.h"
+#include "mozilla/widget/xdg-activation-v1-client-protocol.h"
+#include "mozilla/widget/xdg-output-unstable-v1-client-protocol.h"
+
+namespace mozilla {
+namespace widget {
+
+// Our general connection to Wayland display server,
+// holds our display connection and runs event loop.
+// We have a global nsWaylandDisplay object for each thread.
+class nsWaylandDisplay {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsWaylandDisplay)
+
+  // Create nsWaylandDisplay object on top of native Wayland wl_display
+  // connection.
+  explicit nsWaylandDisplay(wl_display* aDisplay);
+
+  bool DispatchEventQueue();
+
+  void SyncBegin();
+  void QueueSyncBegin();
+  void SyncEnd();
+  void WaitForSyncEnd();
+
+  bool Matches(wl_display* aDisplay);
+
+  wl_display* GetDisplay() { return mDisplay; };
+  wl_event_queue* GetEventQueue() { return mEventQueue; };
+  wl_compositor* GetCompositor() { return mCompositor; };
+  wl_subcompositor* GetSubcompositor() { return mSubcompositor; };
+  wl_shm* GetShm() { return mShm; };
+  zwp_idle_inhibit_manager_v1* GetIdleInhibitManager() {
+    return mIdleInhibitManager;
+  }
+  wp_viewporter* GetViewporter() { return mViewporter; };
+  zwp_relative_pointer_manager_v1* GetRelativePointerManager() {
+    return mRelativePointerManager;
+  }
+  zwp_pointer_constraints_v1* GetPointerConstraints() {
+    return mPointerConstraints;
+  }
+  zwp_linux_dmabuf_v1* GetDmabuf() { return mDmabuf; };
+  xdg_activation_v1* GetXdgActivation() { return mXdgActivation; };
+
+  bool IsMainThreadDisplay() { return mEventQueue == nullptr; }
+
+  void SetShm(wl_shm* aShm);
+  void SetCompositor(wl_compositor* aCompositor);
+  void SetSubcompositor(wl_subcompositor* aSubcompositor);
+  void SetDataDeviceManager(wl_data_device_manager* aDataDeviceManager);
+  void SetIdleInhibitManager(zwp_idle_inhibit_manager_v1* aIdleInhibitManager);
+  void SetViewporter(wp_viewporter* aViewporter);
+  void SetRelativePointerManager(
+      zwp_relative_pointer_manager_v1* aRelativePointerManager);
+  void SetPointerConstraints(zwp_pointer_constraints_v1* aPointerConstraints);
+  void SetDmabuf(zwp_linux_dmabuf_v1* aDmabuf);
+  void SetXdgActivation(xdg_activation_v1* aXdgActivation);
+
+  bool IsExplicitSyncEnabled() { return mExplicitSync; }
+
+ private:
+  ~nsWaylandDisplay();
+
+  PRThread* mThreadId = nullptr;
+  wl_display* mDisplay = nullptr;
+  wl_event_queue* mEventQueue = nullptr;
+  wl_compositor* mCompositor = nullptr;
+  wl_subcompositor* mSubcompositor = nullptr;
+  wl_shm* mShm = nullptr;
+  wl_callback* mSyncCallback = nullptr;
+  zwp_idle_inhibit_manager_v1* mIdleInhibitManager = nullptr;
+  zwp_relative_pointer_manager_v1* mRelativePointerManager = nullptr;
+  zwp_pointer_constraints_v1* mPointerConstraints = nullptr;
+  wp_viewporter* mViewporter = nullptr;
+  zwp_linux_dmabuf_v1* mDmabuf = nullptr;
+  xdg_activation_v1* mXdgActivation = nullptr;
+  bool mExplicitSync = false;
+};
+
+void WaylandDispatchDisplays();
+void WaylandDisplayRelease();
+
+RefPtr<nsWaylandDisplay> WaylandDisplayGet(GdkDisplay* aGdkDisplay = nullptr);
+wl_display* WaylandDisplayGetWLDisplay(GdkDisplay* aGdkDisplay = nullptr);
+
+}  // namespace widget
+}  // namespace mozilla
+
+template <class T>
+static inline T* WaylandRegistryBind(struct wl_registry* wl_registry,
+                                     uint32_t name,
+                                     const struct wl_interface* interface,
+                                     uint32_t version) {
+  struct wl_proxy* id;
+
+  // When libwayland-client does not provide this symbol, it will be
+  // linked to the fallback in libmozwayland, which returns NULL.
+  id = wl_proxy_marshal_constructor_versioned(
+      (struct wl_proxy*)wl_registry, WL_REGISTRY_BIND, interface, version, name,
+      interface->name, version, nullptr);
+
+  if (id == nullptr) {
+    id = wl_proxy_marshal_constructor((struct wl_proxy*)wl_registry,
+                                      WL_REGISTRY_BIND, interface, name,
+                                      interface->name, version, nullptr);
+  }
+
+  return reinterpret_cast<T*>(id);
+}
+
+#endif  // __MOZ_WAYLAND_DISPLAY_H__
diff --git a/widget/gtk/nsWidgetFactory.cpp b/widget/gtk/nsWidgetFactory.cpp
new file mode 100644
index 0000000000..70b47d5124
--- /dev/null
+++ b/widget/gtk/nsWidgetFactory.cpp
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsWidgetFactory.h"
+
+#include "mozilla/Components.h"
+#include "mozilla/WidgetUtils.h"
+#include "NativeKeyBindings.h"
+#include "nsWidgetsCID.h"
+#include "nsAppShell.h"
+#include "nsAppShellSingleton.h"
+#include "nsBaseWidget.h"
+#include "nsGtkKeyUtils.h"
+#include "nsLookAndFeel.h"
+#include "nsWindow.h"
+#include "nsHTMLFormatConverter.h"
+#include "HeadlessClipboard.h"
+#include "IMContextWrapper.h"
+#include "nsClipboard.h"
+#include "TaskbarProgress.h"
+#include "nsFilePicker.h"
+#include "nsSound.h"
+#include "nsGTKToolkit.h"
+#include "WakeLockListener.h"
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/widget/ScreenManager.h"
+#include <gtk/gtk.h>
+
+using namespace mozilla;
+using namespace mozilla::widget;
+
+NS_IMPL_COMPONENT_FACTORY(nsIClipboard) {
+  nsCOMPtr<nsIClipboard> inst;
+  if (gfxPlatform::IsHeadless()) {
+    inst = new HeadlessClipboard();
+  } else {
+    auto clipboard = MakeRefPtr<nsClipboard>();
+    if (NS_FAILED(clipboard->Init())) {
+      return nullptr;
+    }
+    inst = std::move(clipboard);
+  }
+
+  return inst.forget().downcast<nsISupports>();
+}
+
+nsresult nsWidgetGtk2ModuleCtor() { return nsAppShellInit(); }
+
+void nsWidgetGtk2ModuleDtor() {
+  // Shutdown all XP level widget classes.
+  WidgetUtils::Shutdown();
+
+  NativeKeyBindings::Shutdown();
+  nsLookAndFeel::Shutdown();
+  nsFilePicker::Shutdown();
+  nsSound::Shutdown();
+  nsWindow::ReleaseGlobals();
+  IMContextWrapper::Shutdown();
+  KeymapWrapper::Shutdown();
+  nsGTKToolkit::Shutdown();
+  nsAppShellShutdown();
+#ifdef MOZ_ENABLE_DBUS
+  WakeLockListener::Shutdown();
+#endif
+}
diff --git a/widget/gtk/nsWidgetFactory.h b/widget/gtk/nsWidgetFactory.h
new file mode 100644
index 0000000000..f9312f6274
--- /dev/null
+++ b/widget/gtk/nsWidgetFactory.h
@@ -0,0 +1,21 @@
+/* -*- 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 widget_gtk_nsWidgetFactory_h
+#define widget_gtk_nsWidgetFactory_h
+
+#include "nscore.h"
+#include "nsID.h"
+
+class nsISupports;
+
+nsresult nsAppShellConstructor(const nsIID& iid, void** result);
+
+nsresult nsWidgetGtk2ModuleCtor();
+void nsWidgetGtk2ModuleDtor();
+
+#endif  // defined widget_gtk_nsWidgetFactory_h
diff --git a/widget/gtk/nsWindow.cpp b/widget/gtk/nsWindow.cpp
new file mode 100644
index 0000000000..eb02e1c388
--- /dev/null
+++ b/widget/gtk/nsWindow.cpp
@@ -0,0 +1,9710 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsWindow.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <dlfcn.h>
+#include <gdk/gdkkeysyms.h>
+#include <wchar.h>
+
+#include "VsyncSource.h"
+#include "gfx2DGlue.h"
+#include "gfxContext.h"
+#include "gfxImageSurface.h"
+#include "gfxPlatformGtk.h"
+#include "gfxUtils.h"
+#include "GLContextProvider.h"
+#include "GLContext.h"
+#include "GtkCompositorWidget.h"
+#include "gtkdrawing.h"
+#include "imgIContainer.h"
+#include "InputData.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Components.h"
+#include "mozilla/GRefPtr.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/WheelEventBinding.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/gfx/HelpersCairo.h"
+#include "mozilla/layers/APZThreadUtils.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/KnowsCompositor.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/layers/APZInputBridge.h"
+#include "mozilla/layers/IAPZCTreeManager.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/NativeKeyBindingsType.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/StaticPrefs_apz.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/StaticPrefs_mozilla.h"
+#include "mozilla/StaticPrefs_ui.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/SwipeTracker.h"
+#include "mozilla/TextEventDispatcher.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/WidgetUtils.h"
+#include "mozilla/WritingModes.h"
+#ifdef MOZ_X11
+#  include "mozilla/X11Util.h"
+#endif
+#include "mozilla/XREAppData.h"
+#include "NativeKeyBindings.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsAppRunner.h"
+#include "nsDragService.h"
+#include "nsGTKToolkit.h"
+#include "nsGtkKeyUtils.h"
+#include "nsGtkCursors.h"
+#include "nsGfxCIID.h"
+#include "nsGtkUtils.h"
+#include "nsIFile.h"
+#include "nsIGSettingsService.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsImageToPixbuf.h"
+#include "nsINode.h"
+#include "nsIRollupListener.h"
+#include "nsIScreenManager.h"
+#include "nsIUserIdleServiceInternal.h"
+#include "nsIWidgetListener.h"
+#include "nsLayoutUtils.h"
+#include "nsMenuPopupFrame.h"
+#include "nsPresContext.h"
+#include "nsShmImage.h"
+#include "nsString.h"
+#include "nsWidgetsCID.h"
+#include "nsViewManager.h"
+#include "nsXPLookAndFeel.h"
+#include "prlink.h"
+#include "ScreenHelperGTK.h"
+#include "SystemTimeConverter.h"
+#include "WidgetUtilsGtk.h"
+
+#ifdef ACCESSIBILITY
+#  include "mozilla/a11y/LocalAccessible.h"
+#  include "mozilla/a11y/Platform.h"
+#  include "nsAccessibilityService.h"
+#endif
+
+#ifdef MOZ_X11
+#  include <gdk/gdkkeysyms-compat.h>
+#  include <X11/Xatom.h>
+#  include <X11/extensions/XShm.h>
+#  include <X11/extensions/shape.h>
+#  include "gfxXlibSurface.h"
+#  include "GLContextGLX.h"  // for GLContextGLX::FindVisual()
+#  include "GLContextEGL.h"  // for GLContextEGL::FindVisual()
+#  include "WindowSurfaceX11Image.h"
+#  include "WindowSurfaceX11SHM.h"
+#endif
+#ifdef MOZ_WAYLAND
+#  include <gdk/gdkkeysyms-compat.h>
+#  include "nsIClipboard.h"
+#  include "nsView.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+using namespace mozilla::widget;
+#ifdef MOZ_X11
+using mozilla::gl::GLContextEGL;
+using mozilla::gl::GLContextGLX;
+#endif
+
+// Don't put more than this many rects in the dirty region, just fluff
+// out to the bounding-box if there are more
+#define MAX_RECTS_IN_REGION 100
+
+#if !GTK_CHECK_VERSION(3, 18, 0)
+
+struct _GdkEventTouchpadPinch {
+  GdkEventType type;
+  GdkWindow* window;
+  gint8 send_event;
+  gint8 phase;
+  gint8 n_fingers;
+  guint32 time;
+  gdouble x;
+  gdouble y;
+  gdouble dx;
+  gdouble dy;
+  gdouble angle_delta;
+  gdouble scale;
+  gdouble x_root, y_root;
+  guint state;
+};
+
+typedef enum {
+  GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
+  GDK_TOUCHPAD_GESTURE_PHASE_UPDATE,
+  GDK_TOUCHPAD_GESTURE_PHASE_END,
+  GDK_TOUCHPAD_GESTURE_PHASE_CANCEL
+} GdkTouchpadGesturePhase;
+
+gint GDK_TOUCHPAD_GESTURE_MASK = 1 << 24;
+GdkEventType GDK_TOUCHPAD_PINCH = static_cast<GdkEventType>(42);
+
+#endif
+
+const gint kEvents = GDK_TOUCHPAD_GESTURE_MASK | GDK_EXPOSURE_MASK |
+                     GDK_STRUCTURE_MASK | GDK_VISIBILITY_NOTIFY_MASK |
+                     GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
+                     GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+                     GDK_SMOOTH_SCROLL_MASK | GDK_TOUCH_MASK | GDK_SCROLL_MASK |
+                     GDK_POINTER_MOTION_MASK | GDK_PROPERTY_CHANGE_MASK;
+
+/* utility functions */
+static bool is_mouse_in_window(GdkWindow* aWindow, gdouble aMouseX,
+                               gdouble aMouseY);
+static nsWindow* get_window_for_gtk_widget(GtkWidget* widget);
+static nsWindow* get_window_for_gdk_window(GdkWindow* window);
+static GtkWidget* get_gtk_widget_for_gdk_window(GdkWindow* window);
+static GdkCursor* get_gtk_cursor(nsCursor aCursor);
+static GdkWindow* get_inner_gdk_window(GdkWindow* aWindow, gint x, gint y,
+                                       gint* retx, gint* rety);
+
+/* callbacks from widgets */
+static gboolean expose_event_cb(GtkWidget* widget, cairo_t* cr);
+static gboolean configure_event_cb(GtkWidget* widget, GdkEventConfigure* event);
+static void widget_map_cb(GtkWidget* widget);
+static void widget_unmap_cb(GtkWidget* widget);
+static void widget_unrealize_cb(GtkWidget* widget);
+static void size_allocate_cb(GtkWidget* widget, GtkAllocation* allocation);
+static void toplevel_window_size_allocate_cb(GtkWidget* widget,
+                                             GtkAllocation* allocation);
+static gboolean delete_event_cb(GtkWidget* widget, GdkEventAny* event);
+static gboolean enter_notify_event_cb(GtkWidget* widget,
+                                      GdkEventCrossing* event);
+static gboolean leave_notify_event_cb(GtkWidget* widget,
+                                      GdkEventCrossing* event);
+static gboolean motion_notify_event_cb(GtkWidget* widget,
+                                       GdkEventMotion* event);
+MOZ_CAN_RUN_SCRIPT static gboolean button_press_event_cb(GtkWidget* widget,
+                                                         GdkEventButton* event);
+static gboolean button_release_event_cb(GtkWidget* widget,
+                                        GdkEventButton* event);
+static gboolean focus_in_event_cb(GtkWidget* widget, GdkEventFocus* event);
+static gboolean focus_out_event_cb(GtkWidget* widget, GdkEventFocus* event);
+static gboolean key_press_event_cb(GtkWidget* widget, GdkEventKey* event);
+static gboolean key_release_event_cb(GtkWidget* widget, GdkEventKey* event);
+static gboolean property_notify_event_cb(GtkWidget* widget,
+                                         GdkEventProperty* event);
+static gboolean scroll_event_cb(GtkWidget* widget, GdkEventScroll* event);
+
+static void hierarchy_changed_cb(GtkWidget* widget,
+                                 GtkWidget* previous_toplevel);
+static gboolean window_state_event_cb(GtkWidget* widget,
+                                      GdkEventWindowState* event);
+static void settings_xft_dpi_changed_cb(GtkSettings* settings,
+                                        GParamSpec* pspec, nsWindow* data);
+static void check_resize_cb(GtkContainer* container, gpointer user_data);
+static void screen_composited_changed_cb(GdkScreen* screen, gpointer user_data);
+static void widget_composited_changed_cb(GtkWidget* widget, gpointer user_data);
+
+static void scale_changed_cb(GtkWidget* widget, GParamSpec* aPSpec,
+                             gpointer aPointer);
+static gboolean touch_event_cb(GtkWidget* aWidget, GdkEventTouch* aEvent);
+static gboolean generic_event_cb(GtkWidget* widget, GdkEvent* aEvent);
+
+static nsWindow* GetFirstNSWindowForGDKWindow(GdkWindow* aGdkWindow);
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#ifdef MOZ_X11
+static GdkFilterReturn popup_take_focus_filter(GdkXEvent* gdk_xevent,
+                                               GdkEvent* event, gpointer data);
+#endif /* MOZ_X11 */
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+static gboolean drag_motion_event_cb(GtkWidget* aWidget,
+                                     GdkDragContext* aDragContext, gint aX,
+                                     gint aY, guint aTime, gpointer aData);
+static void drag_leave_event_cb(GtkWidget* aWidget,
+                                GdkDragContext* aDragContext, guint aTime,
+                                gpointer aData);
+static gboolean drag_drop_event_cb(GtkWidget* aWidget,
+                                   GdkDragContext* aDragContext, gint aX,
+                                   gint aY, guint aTime, gpointer aData);
+static void drag_data_received_event_cb(GtkWidget* aWidget,
+                                        GdkDragContext* aDragContext, gint aX,
+                                        gint aY,
+                                        GtkSelectionData* aSelectionData,
+                                        guint aInfo, guint32 aTime,
+                                        gpointer aData);
+
+/* initialization static functions */
+static nsresult initialize_prefs(void);
+
+static guint32 sLastUserInputTime = GDK_CURRENT_TIME;
+
+static SystemTimeConverter<guint32>& TimeConverter() {
+  static SystemTimeConverter<guint32> sTimeConverterSingleton;
+  return sTimeConverterSingleton;
+}
+
+bool nsWindow::sTransparentMainWindow = false;
+
+// forward declare from mozgtk
+extern "C" MOZ_EXPORT void mozgtk_linker_holder();
+
+namespace mozilla {
+
+#ifdef MOZ_X11
+class CurrentX11TimeGetter {
+ public:
+  explicit CurrentX11TimeGetter(GdkWindow* aWindow)
+      : mWindow(aWindow), mAsyncUpdateStart() {}
+
+  guint32 GetCurrentTime() const { return gdk_x11_get_server_time(mWindow); }
+
+  void GetTimeAsyncForPossibleBackwardsSkew(const TimeStamp& aNow) {
+    // Check for in-flight request
+    if (!mAsyncUpdateStart.IsNull()) {
+      return;
+    }
+    mAsyncUpdateStart = aNow;
+
+    Display* xDisplay = GDK_WINDOW_XDISPLAY(mWindow);
+    Window xWindow = GDK_WINDOW_XID(mWindow);
+    unsigned char c = 'a';
+    Atom timeStampPropAtom = TimeStampPropAtom();
+    XChangeProperty(xDisplay, xWindow, timeStampPropAtom, timeStampPropAtom, 8,
+                    PropModeReplace, &c, 1);
+    XFlush(xDisplay);
+  }
+
+  gboolean PropertyNotifyHandler(GtkWidget* aWidget, GdkEventProperty* aEvent) {
+    if (aEvent->atom != gdk_x11_xatom_to_atom(TimeStampPropAtom())) {
+      return FALSE;
+    }
+
+    guint32 eventTime = aEvent->time;
+    TimeStamp lowerBound = mAsyncUpdateStart;
+
+    TimeConverter().CompensateForBackwardsSkew(eventTime, lowerBound);
+    mAsyncUpdateStart = TimeStamp();
+    return TRUE;
+  }
+
+ private:
+  static Atom TimeStampPropAtom() {
+    return gdk_x11_get_xatom_by_name_for_display(gdk_display_get_default(),
+                                                 "GDK_TIMESTAMP_PROP");
+  }
+
+  // This is safe because this class is stored as a member of mWindow and
+  // won't outlive it.
+  GdkWindow* mWindow;
+  TimeStamp mAsyncUpdateStart;
+};
+#endif
+
+}  // namespace mozilla
+
+// The window from which the focus manager asks us to dispatch key events.
+static nsWindow* gFocusWindow = nullptr;
+static bool gBlockActivateEvent = false;
+static bool gGlobalsInitialized = false;
+static bool gUseAspectRatio = true;
+static uint32_t gLastTouchID = 0;
+// See Bug 1777269 for details. We don't know if the suspected leave notify
+// event is a correct one when we get it.
+// Store it and issue it later from enter notify event if it's correct,
+// throw it away otherwise.
+static GUniquePtr<GdkEventCrossing> sStoredLeaveNotifyEvent;
+
+#define NS_WINDOW_TITLE_MAX_LENGTH 4095
+#define kWindowPositionSlop 20
+
+// cursor cache
+static GdkCursor* gCursorCache[eCursorCount];
+
+// Sometimes this actually also includes the state of the modifier keys, but
+// only the button state bits are used.
+static guint gButtonState;
+
+static inline int32_t GetBitmapStride(int32_t width) {
+#if defined(MOZ_X11)
+  return (width + 7) / 8;
+#else
+  return cairo_format_stride_for_width(CAIRO_FORMAT_A1, width);
+#endif
+}
+
+static inline bool TimestampIsNewerThan(guint32 a, guint32 b) {
+  // Timestamps are just the least significant bits of a monotonically
+  // increasing function, and so the use of unsigned overflow arithmetic.
+  return a - b <= G_MAXUINT32 / 2;
+}
+
+static void UpdateLastInputEventTime(void* aGdkEvent) {
+  nsCOMPtr<nsIUserIdleServiceInternal> idleService =
+      do_GetService("@mozilla.org/widget/useridleservice;1");
+  if (idleService) {
+    idleService->ResetIdleTimeOut(0);
+  }
+
+  guint timestamp = gdk_event_get_time(static_cast<GdkEvent*>(aGdkEvent));
+  if (timestamp == GDK_CURRENT_TIME) return;
+
+  sLastUserInputTime = timestamp;
+}
+
+// Don't set parent (transient for) if nothing changes.
+// gtk_window_set_transient_for() blows up wl_subsurfaces used by aWindow
+// even if aParent is the same.
+static void GtkWindowSetTransientFor(GtkWindow* aWindow, GtkWindow* aParent) {
+  GtkWindow* parent = gtk_window_get_transient_for(aWindow);
+  if (parent != aParent) {
+    gtk_window_set_transient_for(aWindow, aParent);
+  }
+}
+
+#define gtk_window_set_transient_for(a, b)                         \
+  {                                                                \
+    MOZ_ASSERT_UNREACHABLE(                                        \
+        "gtk_window_set_transient_for() can't be used directly."); \
+  }
+
+nsWindow::nsWindow()
+    : mIsDestroyed(false),
+      mIsShown(false),
+      mNeedsShow(false),
+      mIsMapped(false),
+      mEnabled(true),
+      mCreated(false),
+      mHandleTouchEvent(false),
+      mIsDragPopup(false),
+      mWindowScaleFactorChanged(true),
+      mCompositedScreen(gdk_screen_is_composited(gdk_screen_get_default())),
+      mIsAccelerated(false),
+      mWindowShouldStartDragging(false),
+      mHasMappedToplevel(false),
+      mRetryPointerGrab(false),
+      mPanInProgress(false),
+      mDrawToContainer(false),
+      mTitlebarBackdropState(false),
+      mIsPIPWindow(false),
+      mIsWaylandPanelWindow(false),
+      mIsChildWindow(false),
+      mAlwaysOnTop(false),
+      mNoAutoHide(false),
+      mIsTransparent(false),
+      mHasReceivedSizeAllocate(false),
+      mPopupTrackInHierarchy(false),
+      mPopupTrackInHierarchyConfigured(false),
+      mHiddenPopupPositioned(false),
+      mTransparencyBitmapForTitlebar(false),
+      mHasAlphaVisual(false),
+      mPopupAnchored(false),
+      mPopupContextMenu(false),
+      mPopupMatchesLayout(false),
+      mPopupChanged(false),
+      mPopupTemporaryHidden(false),
+      mPopupClosed(false),
+      mPopupUseMoveToRect(false),
+      mWaitingForMoveToRectCallback(false),
+      mMovedAfterMoveToRect(false),
+      mResizedAfterMoveToRect(false),
+      mConfiguredClearColor(false),
+      mGotNonBlankPaint(false),
+      mNeedsToRetryCapturingMouse(false) {
+  mWindowType = eWindowType_child;
+  mSizeConstraints.mMaxSize = GetSafeWindowSize(mSizeConstraints.mMaxSize);
+
+  if (!gGlobalsInitialized) {
+    gGlobalsInitialized = true;
+
+    // It's OK if either of these fail, but it may not be one day.
+    initialize_prefs();
+
+#ifdef MOZ_WAYLAND
+    // Wayland provides clipboard data to application on focus-in event
+    // so we need to init our clipboard hooks before we create window
+    // and get focus.
+    if (GdkIsWaylandDisplay()) {
+      nsCOMPtr<nsIClipboard> clipboard =
+          do_GetService("@mozilla.org/widget/clipboard;1");
+      NS_ASSERTION(clipboard, "Failed to init clipboard!");
+    }
+#endif
+  }
+  // Dummy call to mozgtk to prevent the linker from removing
+  // the dependency with --as-needed.
+  // see toolkit/library/moz.build for details.
+  mozgtk_linker_holder();
+}
+
+nsWindow::~nsWindow() {
+  LOG("nsWindow::~nsWindow()");
+  Destroy();
+}
+
+/* static */
+void nsWindow::ReleaseGlobals() {
+  for (auto& cursor : gCursorCache) {
+    if (cursor) {
+      g_object_unref(cursor);
+      cursor = nullptr;
+    }
+  }
+}
+
+void nsWindow::DispatchActivateEvent(void) {
+  NS_ASSERTION(mContainer || mIsDestroyed,
+               "DispatchActivateEvent only intended for container windows");
+
+#ifdef ACCESSIBILITY
+  DispatchActivateEventAccessible();
+#endif  // ACCESSIBILITY
+
+  if (mWidgetListener) mWidgetListener->WindowActivated();
+}
+
+void nsWindow::DispatchDeactivateEvent(void) {
+  if (mWidgetListener) mWidgetListener->WindowDeactivated();
+
+#ifdef ACCESSIBILITY
+  DispatchDeactivateEventAccessible();
+#endif  // ACCESSIBILITY
+}
+
+void nsWindow::DispatchResized() {
+  LOG("nsWindow::DispatchResized() size [%d, %d]", (int)(mBounds.width),
+      (int)(mBounds.height));
+
+  mNeedsDispatchSize = LayoutDeviceIntSize(-1, -1);
+  if (mWidgetListener) {
+    mWidgetListener->WindowResized(this, mBounds.width, mBounds.height);
+  }
+  if (mAttachedWidgetListener) {
+    mAttachedWidgetListener->WindowResized(this, mBounds.width, mBounds.height);
+  }
+}
+
+void nsWindow::MaybeDispatchResized() {
+  if (mNeedsDispatchSize != LayoutDeviceIntSize(-1, -1) && !mIsDestroyed) {
+    mBounds.SizeTo(mNeedsDispatchSize);
+    // Check mBounds size
+    if (mCompositorSession &&
+        !wr::WindowSizeSanityCheck(mBounds.width, mBounds.height)) {
+      gfxCriticalNoteOnce << "Invalid mBounds in MaybeDispatchResized "
+                          << mBounds << " size state " << mSizeMode;
+    }
+
+    if (mWindowType == eWindowType_toplevel) {
+      UpdateTopLevelOpaqueRegion();
+    }
+
+    // Notify the GtkCompositorWidget of a ClientSizeChange
+    if (mCompositorWidgetDelegate) {
+      mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize());
+    }
+
+    DispatchResized();
+  }
+}
+
+nsIWidgetListener* nsWindow::GetListener() {
+  return mAttachedWidgetListener ? mAttachedWidgetListener : mWidgetListener;
+}
+
+nsresult nsWindow::DispatchEvent(WidgetGUIEvent* aEvent,
+                                 nsEventStatus& aStatus) {
+#ifdef DEBUG
+  debug_DumpEvent(stdout, aEvent->mWidget, aEvent, "something", 0);
+#endif
+  aStatus = nsEventStatus_eIgnore;
+  nsIWidgetListener* listener = GetListener();
+  if (listener) {
+    aStatus = listener->HandleEvent(aEvent, mUseAttachedEvents);
+  }
+
+  return NS_OK;
+}
+
+void nsWindow::OnDestroy(void) {
+  if (mOnDestroyCalled) return;
+
+  mOnDestroyCalled = true;
+
+  // Prevent deletion.
+  nsCOMPtr<nsIWidget> kungFuDeathGrip = this;
+
+  // release references to children, device context, toolkit + app shell
+  nsBaseWidget::OnDestroy();
+
+  // Remove association between this object and its parent and siblings.
+  nsBaseWidget::Destroy();
+  mParent = nullptr;
+
+  NotifyWindowDestroyed();
+}
+
+bool nsWindow::AreBoundsSane() {
+  // Check requested size, as mBounds might not have been updated.
+  return !mLastSizeRequest.IsEmpty();
+}
+
+// Walk the list of child windows and call destroy on them.
+void nsWindow::DestroyChildWindows() {
+  LOG("nsWindow::DestroyChildWindows()");
+  if (!mGdkWindow) {
+    return;
+  }
+  while (GList* children = gdk_window_peek_children(mGdkWindow)) {
+    GdkWindow* child = GDK_WINDOW(children->data);
+    nsWindow* kid = get_window_for_gdk_window(child);
+    if (kid) {
+      kid->Destroy();
+    }
+  }
+}
+
+void nsWindow::Destroy() {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+
+  if (mIsDestroyed || !mCreated) {
+    return;
+  }
+
+  LOG("nsWindow::Destroy\n");
+
+  mIsDestroyed = true;
+  mCreated = false;
+
+  MozClearHandleID(mCompositorPauseTimeoutID, g_source_remove);
+
+  ClearTransparencyBitmap();
+
+#ifdef MOZ_WAYLAND
+  // Shut down our local vsync source
+  if (mWaylandVsyncSource) {
+    mWaylandVsyncSource->Shutdown();
+    mWaylandVsyncSource = nullptr;
+  }
+  mWaylandVsyncDispatcher = nullptr;
+#endif
+
+  /** Need to clean our LayerManager up while still alive */
+  DestroyLayerManager();
+
+  // Ensure any resources assigned to the window get cleaned up first
+  // to avoid double-freeing.
+  mSurfaceProvider.CleanupResources();
+
+  g_signal_handlers_disconnect_by_data(gtk_settings_get_default(), this);
+
+  nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener();
+  if (rollupListener) {
+    nsCOMPtr<nsIWidget> rollupWidget = rollupListener->GetRollupWidget();
+    if (static_cast<nsIWidget*>(this) == rollupWidget) {
+      rollupListener->Rollup(0, false, nullptr, nullptr);
+    }
+  }
+
+  // dragService will be null after shutdown of the service manager.
+  RefPtr<nsDragService> dragService = nsDragService::GetInstance();
+  if (dragService && this == dragService->GetMostRecentDestWindow()) {
+    dragService->ScheduleLeaveEvent();
+  }
+
+  NativeShow(false);
+
+  if (mIMContext) {
+    mIMContext->OnDestroyWindow(this);
+  }
+
+  // make sure that we remove ourself as the focus window
+  if (gFocusWindow == this) {
+    LOG("automatically losing focus...\n");
+    gFocusWindow = nullptr;
+  }
+
+  if (sStoredLeaveNotifyEvent) {
+    nsWindow* window =
+        get_window_for_gdk_window(sStoredLeaveNotifyEvent->window);
+    if (window == this) {
+      sStoredLeaveNotifyEvent = nullptr;
+    }
+  }
+
+  gtk_widget_destroy(mShell);
+  mShell = nullptr;
+  mContainer = nullptr;
+
+  MOZ_ASSERT(!mGdkWindow,
+             "mGdkWindow should be NULL when mContainer is destroyed");
+
+#ifdef ACCESSIBILITY
+  if (mRootAccessible) {
+    mRootAccessible = nullptr;
+  }
+#endif
+
+  // Save until last because OnDestroy() may cause us to be deleted.
+  OnDestroy();
+}
+
+nsIWidget* nsWindow::GetParent() { return mParent; }
+
+float nsWindow::GetDPI() {
+  float dpi = 96.0f;
+  nsCOMPtr<nsIScreen> screen = GetWidgetScreen();
+  if (screen) {
+    screen->GetDpi(&dpi);
+  }
+  return dpi;
+}
+
+double nsWindow::GetDefaultScaleInternal() { return FractionalScaleFactor(); }
+
+DesktopToLayoutDeviceScale nsWindow::GetDesktopToDeviceScale() {
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay()) {
+    return DesktopToLayoutDeviceScale(GdkCeiledScaleFactor());
+  }
+#endif
+
+  // In Gtk/X11, we manage windows using device pixels.
+  return DesktopToLayoutDeviceScale(1.0);
+}
+
+DesktopToLayoutDeviceScale nsWindow::GetDesktopToDeviceScaleByScreen() {
+#ifdef MOZ_WAYLAND
+  // In Wayland there's no way to get absolute position of the window and use it
+  // to determine the screen factor of the monitor on which the window is
+  // placed. The window is notified of the current scale factor but not at this
+  // point, so the GdkScaleFactor can return wrong value which can lead to wrong
+  // popup placement. We need to use parent's window scale factor for the new
+  // one.
+  if (GdkIsWaylandDisplay()) {
+    nsView* view = nsView::GetViewFor(this);
+    if (view) {
+      nsView* parentView = view->GetParent();
+      if (parentView) {
+        nsIWidget* parentWidget = parentView->GetNearestWidget(nullptr);
+        if (parentWidget) {
+          return DesktopToLayoutDeviceScale(
+              parentWidget->RoundsWidgetCoordinatesTo());
+        }
+        NS_WARNING("Widget has no parent");
+      }
+    } else {
+      NS_WARNING("Cannot find widget view");
+    }
+  }
+#endif
+  return nsBaseWidget::GetDesktopToDeviceScale();
+}
+
+// Reparent a child window to a new parent.
+void nsWindow::SetParent(nsIWidget* aNewParent) {
+  LOG("nsWindow::SetParent() new parent %p", aNewParent);
+  if (!mIsChildWindow) {
+    NS_WARNING("Used by child widgets only");
+    return;
+  }
+
+  nsCOMPtr<nsIWidget> kungFuDeathGrip = this;
+  if (mParent) {
+    mParent->RemoveChild(this);
+  }
+  mParent = aNewParent;
+
+  // We're already deleted, quit.
+  if (!mGdkWindow || mIsDestroyed || !aNewParent) {
+    return;
+  }
+  aNewParent->AddChild(this);
+
+  auto* newParent = static_cast<nsWindow*>(aNewParent);
+
+  // New parent is deleted, quit.
+  if (newParent->mIsDestroyed) {
+    Destroy();
+    return;
+  }
+
+  GdkWindow* window = GetToplevelGdkWindow();
+  GdkWindow* parentWindow = newParent->GetToplevelGdkWindow();
+  LOG("  child GdkWindow %p set parent GdkWindow %p", window, parentWindow);
+  gdk_window_reparent(window, parentWindow, 0, 0);
+  SetHasMappedToplevel(newParent && newParent->mHasMappedToplevel);
+}
+
+bool nsWindow::WidgetTypeSupportsAcceleration() {
+  if (mWindowType == eWindowType_invisible) {
+    return false;
+  }
+
+  if (IsSmallPopup()) {
+    return false;
+  }
+  // Workaround for Bug 1479135
+  // We draw transparent popups on non-compositing screens by SW as we don't
+  // implement X shape masks in WebRender.
+  if (mWindowType == eWindowType_popup) {
+    return HasRemoteContent() && mCompositedScreen;
+  }
+
+  return true;
+}
+
+void nsWindow::ReparentNativeWidget(nsIWidget* aNewParent) {
+  MOZ_ASSERT(aNewParent, "null widget");
+  MOZ_ASSERT(!mIsDestroyed, "");
+  MOZ_ASSERT(!static_cast<nsWindow*>(aNewParent)->mIsDestroyed, "");
+  MOZ_ASSERT(
+      !mParent,
+      "nsWindow::ReparentNativeWidget() works on toplevel windows only.");
+
+  auto* newParent = static_cast<nsWindow*>(aNewParent);
+  GtkWindow* newParentWidget = GTK_WINDOW(newParent->GetGtkWidget());
+
+  LOG("nsWindow::ReparentNativeWidget new parent %p\n", newParent);
+  GtkWindowSetTransientFor(GTK_WINDOW(mShell), newParentWidget);
+}
+
+void nsWindow::SetModal(bool aModal) {
+  LOG("nsWindow::SetModal %d\n", aModal);
+  if (mIsDestroyed) return;
+  gtk_window_set_modal(GTK_WINDOW(mShell), aModal ? TRUE : FALSE);
+}
+
+// nsIWidget method, which means IsShown.
+bool nsWindow::IsVisible() const { return mIsShown; }
+
+void nsWindow::RegisterTouchWindow() {
+  mHandleTouchEvent = true;
+  mTouches.Clear();
+}
+
+void nsWindow::ConstrainPosition(bool aAllowSlop, int32_t* aX, int32_t* aY) {
+  if (!mShell || GdkIsWaylandDisplay()) {
+    return;
+  }
+
+  double dpiScale = GetDefaultScale().scale;
+
+  // we need to use the window size in logical screen pixels
+  int32_t logWidth = std::max(NSToIntRound(mBounds.width / dpiScale), 1);
+  int32_t logHeight = std::max(NSToIntRound(mBounds.height / dpiScale), 1);
+
+  /* get our playing field. use the current screen, or failing that
+    for any reason, use device caps for the default screen. */
+  nsCOMPtr<nsIScreen> screen;
+  nsCOMPtr<nsIScreenManager> screenmgr =
+      do_GetService("@mozilla.org/gfx/screenmanager;1");
+  if (screenmgr) {
+    screenmgr->ScreenForRect(*aX, *aY, logWidth, logHeight,
+                             getter_AddRefs(screen));
+  }
+
+  // We don't have any screen so leave the coordinates as is
+  if (!screen) return;
+
+  nsIntRect screenRect;
+  if (mSizeMode != nsSizeMode_Fullscreen) {
+    // For normalized windows, use the desktop work area.
+    screen->GetAvailRectDisplayPix(&screenRect.x, &screenRect.y,
+                                   &screenRect.width, &screenRect.height);
+  } else {
+    // For full screen windows, use the desktop.
+    screen->GetRectDisplayPix(&screenRect.x, &screenRect.y, &screenRect.width,
+                              &screenRect.height);
+  }
+
+  if (aAllowSlop) {
+    if (*aX < screenRect.x - logWidth + kWindowPositionSlop) {
+      *aX = screenRect.x - logWidth + kWindowPositionSlop;
+    } else if (*aX >= screenRect.XMost() - kWindowPositionSlop) {
+      *aX = screenRect.XMost() - kWindowPositionSlop;
+    }
+
+    if (*aY < screenRect.y - logHeight + kWindowPositionSlop) {
+      *aY = screenRect.y - logHeight + kWindowPositionSlop;
+    } else if (*aY >= screenRect.YMost() - kWindowPositionSlop) {
+      *aY = screenRect.YMost() - kWindowPositionSlop;
+    }
+  } else {
+    if (*aX < screenRect.x) {
+      *aX = screenRect.x;
+    } else if (*aX >= screenRect.XMost() - logWidth) {
+      *aX = screenRect.XMost() - logWidth;
+    }
+
+    if (*aY < screenRect.y) {
+      *aY = screenRect.y;
+    } else if (*aY >= screenRect.YMost() - logHeight) {
+      *aY = screenRect.YMost() - logHeight;
+    }
+  }
+}
+
+void nsWindow::SetSizeConstraints(const SizeConstraints& aConstraints) {
+  mSizeConstraints.mMinSize = GetSafeWindowSize(aConstraints.mMinSize);
+  mSizeConstraints.mMaxSize = GetSafeWindowSize(aConstraints.mMaxSize);
+
+  ApplySizeConstraints();
+}
+
+void nsWindow::AddCSDDecorationSize(int* aWidth, int* aHeight) {
+  if (mSizeMode == nsSizeMode_Normal &&
+      mGtkWindowDecoration == GTK_DECORATION_CLIENT && mDrawInTitlebar) {
+    GtkBorder decorationSize = GetCSDDecorationSize(IsPopup());
+    *aWidth += decorationSize.left + decorationSize.right;
+    *aHeight += decorationSize.top + decorationSize.bottom;
+  }
+}
+
+#ifdef MOZ_WAYLAND
+bool nsWindow::GetCSDDecorationOffset(int* aDx, int* aDy) {
+  if (mSizeMode == nsSizeMode_Normal &&
+      mGtkWindowDecoration == GTK_DECORATION_CLIENT && mDrawInTitlebar) {
+    GtkBorder decorationSize = GetCSDDecorationSize(IsPopup());
+    *aDx = decorationSize.left;
+    *aDy = decorationSize.top;
+    return true;
+  }
+  return false;
+}
+#endif
+
+void nsWindow::ApplySizeConstraints(void) {
+  if (mShell) {
+    GdkGeometry geometry;
+    geometry.min_width =
+        DevicePixelsToGdkCoordRoundUp(mSizeConstraints.mMinSize.width);
+    geometry.min_height =
+        DevicePixelsToGdkCoordRoundUp(mSizeConstraints.mMinSize.height);
+    geometry.max_width =
+        DevicePixelsToGdkCoordRoundDown(mSizeConstraints.mMaxSize.width);
+    geometry.max_height =
+        DevicePixelsToGdkCoordRoundDown(mSizeConstraints.mMaxSize.height);
+
+    uint32_t hints = 0;
+    if (mSizeConstraints.mMinSize != LayoutDeviceIntSize(0, 0)) {
+      if (GdkIsWaylandDisplay()) {
+        gtk_widget_set_size_request(GTK_WIDGET(mContainer), geometry.min_width,
+                                    geometry.min_height);
+      }
+      AddCSDDecorationSize(&geometry.min_width, &geometry.min_height);
+      hints |= GDK_HINT_MIN_SIZE;
+    }
+    if (mSizeConstraints.mMaxSize !=
+        LayoutDeviceIntSize(NS_MAXSIZE, NS_MAXSIZE)) {
+      AddCSDDecorationSize(&geometry.max_width, &geometry.max_height);
+      hints |= GDK_HINT_MAX_SIZE;
+    }
+
+    if (mAspectRatio != 0.0f) {
+      geometry.min_aspect = mAspectRatio;
+      geometry.max_aspect = mAspectRatio;
+      hints |= GDK_HINT_ASPECT;
+    }
+
+    gtk_window_set_geometry_hints(GTK_WINDOW(mShell), nullptr, &geometry,
+                                  GdkWindowHints(hints));
+  }
+}
+
+void nsWindow::Show(bool aState) {
+  if (aState == mIsShown) return;
+
+  mIsShown = aState;
+
+#ifdef MOZ_LOGGING
+  LOG("nsWindow::Show state %d frame %s\n", aState, GetFrameTag().get());
+  if (!aState && mSourceDragContext && GdkIsWaylandDisplay()) {
+    LOG("  closing Drag&Drop source window, D&D will be canceled!");
+  }
+#endif
+
+  // Ok, someone called show on a window that isn't sized to a sane
+  // value.  Mark this window as needing to have Show() called on it
+  // and return.
+  if ((aState && !AreBoundsSane()) || !mCreated) {
+    LOG("\tbounds are insane or window hasn't been created yet\n");
+    mNeedsShow = true;
+    return;
+  }
+
+  // If someone is hiding this widget, clear any needing show flag.
+  if (!aState) mNeedsShow = false;
+
+#ifdef ACCESSIBILITY
+  if (aState && a11y::ShouldA11yBeEnabled()) CreateRootAccessible();
+#endif
+
+  NativeShow(aState);
+}
+
+void nsWindow::ResizeInt(const Maybe<LayoutDeviceIntPoint>& aMove,
+                         LayoutDeviceIntSize aSize) {
+  LOG("nsWindow::ResizeInt w:%d h:%d\n", aSize.width, aSize.height);
+  const bool moved = aMove && *aMove != mBounds.TopLeft();
+  if (moved) {
+    mBounds.MoveTo(*aMove);
+    LOG("  with move to left:%d top:%d", aMove->x.value, aMove->y.value);
+  }
+
+  ConstrainSize(&aSize.width, &aSize.height);
+  LOG("  ConstrainSize: w:%d h;%d\n", aSize.width, aSize.height);
+
+  const bool resized = aSize != mLastSizeRequest || mBounds.Size() != aSize;
+#if MOZ_LOGGING
+  LOG("  resized %d aSize [%d, %d] mLastSizeRequest [%d, %d] mBounds [%d, %d]",
+      resized, aSize.width, aSize.height, mLastSizeRequest.width,
+      mLastSizeRequest.height, mBounds.width, mBounds.height);
+#endif
+
+  // For top-level windows, aSize should possibly be
+  // interpreted as frame bounds, but NativeMoveResize treats these as window
+  // bounds (Bug 581866).
+  mLastSizeRequest = aSize;
+  // Check size
+  if (mCompositorSession &&
+      !wr::WindowSizeSanityCheck(aSize.width, aSize.height)) {
+    gfxCriticalNoteOnce << "Invalid aSize in ResizeInt " << aSize
+                        << " size state " << mSizeMode;
+  }
+
+  // Recalculate aspect ratio when resized from DOM
+  if (mAspectRatio != 0.0) {
+    LockAspectRatio(true);
+  }
+
+  if (!mCreated) {
+    return;
+  }
+
+  if (!moved && !resized) {
+    LOG("  not moved or resized, quit");
+    return;
+  }
+
+  NativeMoveResize(moved, resized);
+
+  // We optimistically assume size changes immediately in two cases:
+  // 1. Override-redirect window: Size is controlled by only us.
+  // 2. Managed window that has not not yet received a size-allocate event:
+  //    Resize() Callers expect initial sizes to be applied synchronously.
+  //    If the size request is not honored, then we'll correct in
+  //    OnSizeAllocate().
+  //
+  // When a managed window has already received a size-allocate, we cannot
+  // assume we'll always get a notification if our request does not get
+  // honored: "If the configure request has not changed, we don't ever resend
+  // it, because it could mean fighting the user or window manager."
+  // https://gitlab.gnome.org/GNOME/gtk/-/blob/3.24.31/gtk/gtkwindow.c#L9782
+  // So we don't update mBounds until OnSizeAllocate() when we know the
+  // request is granted.
+  bool isOrWillBeVisible = mHasReceivedSizeAllocate || mNeedsShow || mIsShown;
+  if (!isOrWillBeVisible ||
+      gtk_window_get_window_type(GTK_WINDOW(mShell)) == GTK_WINDOW_POPUP) {
+    mBounds.SizeTo(aSize);
+    if (mCompositorWidgetDelegate) {
+      mCompositorWidgetDelegate->NotifyClientSizeChanged(aSize);
+    }
+    DispatchResized();
+  }
+}
+
+void nsWindow::Resize(double aWidth, double aHeight, bool aRepaint) {
+  LOG("nsWindow::Resize %f %f\n", aWidth, aHeight);
+
+  double scale =
+      BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0;
+  auto size = LayoutDeviceIntSize::Round(scale * aWidth, scale * aHeight);
+
+  ResizeInt(Nothing(), size);
+}
+
+void nsWindow::Resize(double aX, double aY, double aWidth, double aHeight,
+                      bool aRepaint) {
+  LOG("nsWindow::Resize [%f,%f] -> [%f x %f] repaint %d\n", aX, aY, aWidth,
+      aHeight, aRepaint);
+
+  double scale =
+      BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0;
+  auto size = LayoutDeviceIntSize::Round(scale * aWidth, scale * aHeight);
+  auto topLeft = LayoutDeviceIntPoint::Round(scale * aX, scale * aY);
+
+  ResizeInt(Some(topLeft), size);
+}
+
+void nsWindow::Enable(bool aState) { mEnabled = aState; }
+
+bool nsWindow::IsEnabled() const { return mEnabled; }
+
+void nsWindow::Move(double aX, double aY) {
+  double scale =
+      BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0;
+  int32_t x = NSToIntRound(aX * scale);
+  int32_t y = NSToIntRound(aY * scale);
+
+  LOG("nsWindow::Move to %d x %d\n", x, y);
+
+  if (mSizeMode != nsSizeMode_Normal && (mWindowType == eWindowType_toplevel ||
+                                         mWindowType == eWindowType_dialog)) {
+    LOG("  size state is not normal, bailing");
+    return;
+  }
+
+  // Since a popup window's x/y coordinates are in relation to to
+  // the parent, the parent might have moved so we always move a
+  // popup window.
+  LOG("  bounds %d x %d\n", mBounds.x, mBounds.y);
+  if (x == mBounds.x && y == mBounds.y && mWindowType != eWindowType_popup) {
+    LOG("  position is the same, return\n");
+    return;
+  }
+
+  // XXX Should we do some AreBoundsSane check here?
+
+  mBounds.x = x;
+  mBounds.y = y;
+
+  if (!mCreated) {
+    LOG("  is not created, return.\n");
+    return;
+  }
+
+  NativeMoveResize(/* move */ true, /* resize */ false);
+}
+
+bool nsWindow::IsPopup() const { return mWindowType == eWindowType_popup; }
+
+bool nsWindow::IsWaylandPopup() const {
+  return GdkIsWaylandDisplay() && IsPopup();
+}
+
+static nsMenuPopupFrame* GetMenuPopupFrame(nsIFrame* aFrame) {
+  return do_QueryFrame(aFrame);
+}
+
+void nsWindow::AppendPopupToHierarchyList(nsWindow* aToplevelWindow) {
+  mWaylandToplevel = aToplevelWindow;
+
+  nsWindow* popup = aToplevelWindow;
+  while (popup && popup->mWaylandPopupNext) {
+    popup = popup->mWaylandPopupNext;
+  }
+  popup->mWaylandPopupNext = this;
+
+  mWaylandPopupPrev = popup;
+  mWaylandPopupNext = nullptr;
+  mPopupChanged = true;
+  mPopupClosed = false;
+}
+
+void nsWindow::RemovePopupFromHierarchyList() {
+  // We're already removed from the popup hierarchy
+  if (!IsInPopupHierarchy()) {
+    return;
+  }
+  mWaylandPopupPrev->mWaylandPopupNext = mWaylandPopupNext;
+  if (mWaylandPopupNext) {
+    mWaylandPopupNext->mWaylandPopupPrev = mWaylandPopupPrev;
+    mWaylandPopupNext->mPopupChanged = true;
+  }
+  mWaylandPopupNext = mWaylandPopupPrev = nullptr;
+}
+
+// Gtk refuses to map popup window with x < 0 && y < 0 relative coordinates
+// see https://gitlab.gnome.org/GNOME/gtk/-/issues/4071
+// as a workaround just fool around and place the popup temporary to 0,0.
+bool nsWindow::WaylandPopupRemoveNegativePosition(int* aX, int* aY) {
+  // https://gitlab.gnome.org/GNOME/gtk/-/issues/4071 applies to temporary
+  // windows only
+  GdkWindow* window = gtk_widget_get_window(mShell);
+  if (!window || gdk_window_get_window_type(window) != GDK_WINDOW_TEMP) {
+    return false;
+  }
+
+  LOG("nsWindow::WaylandPopupRemoveNegativePosition()");
+
+  int x, y;
+  gtk_window_get_position(GTK_WINDOW(mShell), &x, &y);
+  bool moveBack = (x < 0 && y < 0);
+  if (moveBack) {
+    gtk_window_move(GTK_WINDOW(mShell), 0, 0);
+    if (aX) {
+      *aX = x;
+    }
+    if (aY) {
+      *aY = y;
+    }
+  }
+
+  gdk_window_get_geometry(window, &x, &y, nullptr, nullptr);
+  if (x < 0 && y < 0) {
+    gdk_window_move(window, 0, 0);
+  }
+
+  return moveBack;
+}
+
+void nsWindow::ShowWaylandPopupWindow() {
+  LOG("nsWindow::ShowWaylandPopupWindow. Expected to see visible.");
+  MOZ_ASSERT(IsWaylandPopup());
+
+  if (!mPopupTrackInHierarchy) {
+    LOG("  popup is not tracked in popup hierarchy, show it now");
+    gtk_widget_show(mShell);
+    return;
+  }
+
+  // Popup position was checked before gdk_window_move_to_rect() callback
+  // so just show it.
+  if (mPopupUseMoveToRect && mWaitingForMoveToRectCallback) {
+    LOG("  active move-to-rect callback, show it as is");
+    gtk_widget_show(mShell);
+    return;
+  }
+
+  if (gtk_widget_is_visible(mShell)) {
+    LOG("  is already visible, quit");
+    return;
+  }
+
+  int x, y;
+  bool moved = WaylandPopupRemoveNegativePosition(&x, &y);
+  gtk_widget_show(mShell);
+  if (moved) {
+    LOG("  move back to (%d, %d) and show", x, y);
+    gtk_window_move(GTK_WINDOW(mShell), x, y);
+  }
+}
+
+void nsWindow::WaylandPopupMarkAsClosed() {
+  LOG("nsWindow::WaylandPopupMarkAsClosed: [%p]\n", this);
+  mPopupClosed = true;
+  // If we have any child popup window notify it about
+  // parent switch.
+  if (mWaylandPopupNext) {
+    mWaylandPopupNext->mPopupChanged = true;
+  }
+}
+
+nsWindow* nsWindow::WaylandPopupFindLast(nsWindow* aPopup) {
+  while (aPopup && aPopup->mWaylandPopupNext) {
+    aPopup = aPopup->mWaylandPopupNext;
+  }
+  return aPopup;
+}
+
+// Hide and potentially removes popup from popup hierarchy.
+void nsWindow::HideWaylandPopupWindow(bool aTemporaryHide,
+                                      bool aRemoveFromPopupList) {
+  LOG("nsWindow::HideWaylandPopupWindow: remove from list %d\n",
+      aRemoveFromPopupList);
+  if (aRemoveFromPopupList) {
+    RemovePopupFromHierarchyList();
+  }
+
+  if (!mPopupClosed) {
+    mPopupClosed = !aTemporaryHide;
+  }
+
+  bool visible = gtk_widget_is_visible(mShell);
+  LOG("  gtk_widget_is_visible() = %d\n", visible);
+
+  // Restore only popups which are really visible
+  mPopupTemporaryHidden = aTemporaryHide && visible;
+
+  // Hide only visible popups or popups closed pernamently.
+  if (visible) {
+    gtk_widget_hide(mShell);
+
+    // If there's pending Move-To-Rect callback and we hide the popup
+    // the callback won't be called any more.
+    mWaitingForMoveToRectCallback = false;
+  }
+
+  if (mPopupClosed) {
+    LOG("  Clearing mMoveToRectPopupSize\n");
+    mMoveToRectPopupSize = {};
+#ifdef MOZ_WAYLAND
+    if (moz_container_wayland_is_waiting_to_show(mContainer)) {
+      // We need to clear rendering queue, see Bug 1782948.
+      LOG("  popup failed to show by Wayland compositor, clear rendering "
+          "queue.");
+      moz_container_wayland_clear_waiting_to_show_flag(mContainer);
+      ClearRenderingQueue();
+    }
+#endif
+  }
+}
+
+void nsWindow::HideWaylandToplevelWindow() {
+  LOG("nsWindow::HideWaylandToplevelWindow: [%p]\n", this);
+  if (mWaylandPopupNext) {
+    nsWindow* popup = WaylandPopupFindLast(mWaylandPopupNext);
+    while (popup->mWaylandToplevel != nullptr) {
+      nsWindow* prev = popup->mWaylandPopupPrev;
+      popup->HideWaylandPopupWindow(/* aTemporaryHide */ false,
+                                    /* aRemoveFromPopupList */ true);
+      popup = prev;
+    }
+  }
+  WaylandStopVsync();
+  gtk_widget_hide(mShell);
+}
+
+void nsWindow::ShowWaylandToplevelWindow() {
+  MOZ_ASSERT(!IsWaylandPopup());
+  LOG("nsWindow::ShowWaylandToplevelWindow");
+  gtk_widget_show(mShell);
+}
+
+void nsWindow::WaylandPopupRemoveClosedPopups() {
+  LOG("nsWindow::WaylandPopupRemoveClosedPopups()");
+  nsWindow* popup = this;
+  while (popup) {
+    nsWindow* next = popup->mWaylandPopupNext;
+    if (popup->mPopupClosed) {
+      popup->HideWaylandPopupWindow(/* aTemporaryHide */ false,
+                                    /* aRemoveFromPopupList */ true);
+    }
+    popup = next;
+  }
+}
+
+// Hide all tooltips except the latest one.
+void nsWindow::WaylandPopupHideTooltips() {
+  LOG("nsWindow::WaylandPopupHideTooltips");
+  MOZ_ASSERT(mWaylandToplevel == nullptr, "Should be called on toplevel only!");
+
+  nsWindow* popup = mWaylandPopupNext;
+  while (popup && popup->mWaylandPopupNext) {
+    if (popup->mPopupType == ePopupTypeTooltip) {
+      LOG("  hidding tooltip [%p]", popup);
+      popup->WaylandPopupMarkAsClosed();
+    }
+    popup = popup->mWaylandPopupNext;
+  }
+}
+
+void nsWindow::WaylandPopupCloseOrphanedPopups() {
+#ifdef MOZ_WAYLAND
+  LOG("nsWindow::WaylandPopupCloseOrphanedPopups");
+  MOZ_ASSERT(mWaylandToplevel == nullptr, "Should be called on toplevel only!");
+
+  nsWindow* popup = mWaylandPopupNext;
+  bool dangling = false;
+  while (popup) {
+    if (!dangling &&
+        moz_container_wayland_is_waiting_to_show(popup->GetMozContainer())) {
+      LOG("  popup [%p] is waiting to show, close all child popups", popup);
+      dangling = true;
+    } else if (dangling) {
+      popup->WaylandPopupMarkAsClosed();
+    }
+    popup = popup->mWaylandPopupNext;
+  }
+#endif
+}
+
+// We can't show popups with remote content or overflow popups
+// on top of regular ones.
+// If there's any remote popup opened, close all parent popups of it.
+void nsWindow::CloseAllPopupsBeforeRemotePopup() {
+  LOG("nsWindow::CloseAllPopupsBeforeRemotePopup");
+  MOZ_ASSERT(mWaylandToplevel == nullptr, "Should be called on toplevel only!");
+
+  // Don't waste time when there's only one popup opened.
+  if (!mWaylandPopupNext || mWaylandPopupNext->mWaylandPopupNext == nullptr) {
+    return;
+  }
+
+  // Find the first opened remote content popup
+  nsWindow* remotePopup = mWaylandPopupNext;
+  while (remotePopup) {
+    if (remotePopup->HasRemoteContent() ||
+        remotePopup->IsWidgetOverflowWindow()) {
+      LOG("  remote popup [%p]", remotePopup);
+      break;
+    }
+    remotePopup = remotePopup->mWaylandPopupNext;
+  }
+
+  if (!remotePopup) {
+    return;
+  }
+
+  // ...hide opened popups before the remote one.
+  nsWindow* popup = mWaylandPopupNext;
+  while (popup && popup != remotePopup) {
+    LOG("  hidding popup [%p]", popup);
+    popup->WaylandPopupMarkAsClosed();
+    popup = popup->mWaylandPopupNext;
+  }
+}
+
+static void GetLayoutPopupWidgetChain(
+    nsTArray<nsIWidget*>* aLayoutWidgetHierarchy) {
+  nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+  pm->GetSubmenuWidgetChain(aLayoutWidgetHierarchy);
+  aLayoutWidgetHierarchy->Reverse();
+}
+
+// Compare 'this' popup position in Wayland widget hierarchy
+// (mWaylandPopupPrev/mWaylandPopupNext) with
+// 'this' popup position in layout hierarchy.
+//
+// When aMustMatchParent is true we also request
+// 'this' parents match, i.e. 'this' has the same parent in
+// both layout and widget hierarchy.
+bool nsWindow::IsPopupInLayoutPopupChain(
+    nsTArray<nsIWidget*>* aLayoutWidgetHierarchy, bool aMustMatchParent) {
+  int len = (int)aLayoutWidgetHierarchy->Length();
+  for (int i = 0; i < len; i++) {
+    if (this == (*aLayoutWidgetHierarchy)[i]) {
+      if (!aMustMatchParent) {
+        return true;
+      }
+
+      // Find correct parent popup for 'this' according to widget
+      // hierarchy. That means we need to skip closed popups.
+      nsWindow* parentPopup = nullptr;
+      if (mWaylandPopupPrev != mWaylandToplevel) {
+        parentPopup = mWaylandPopupPrev;
+        while (parentPopup != mWaylandToplevel && parentPopup->mPopupClosed) {
+          parentPopup = parentPopup->mWaylandPopupPrev;
+        }
+      }
+
+      if (i == 0) {
+        // We found 'this' popups as a first popup in layout hierarchy.
+        // It matches layout hierarchy if it's first widget also in
+        // wayland widget hierarchy (i.e. parent is null).
+        return parentPopup == nullptr;
+      }
+
+      return parentPopup == (*aLayoutWidgetHierarchy)[i - 1];
+    }
+  }
+  return false;
+}
+
+// Hide popups which are not in popup chain.
+void nsWindow::WaylandPopupHierarchyHideByLayout(
+    nsTArray<nsIWidget*>* aLayoutWidgetHierarchy) {
+  LOG("nsWindow::WaylandPopupHierarchyHideByLayout");
+  MOZ_ASSERT(mWaylandToplevel == nullptr, "Should be called on toplevel only!");
+
+  // Hide all popups which are not in layout popup chain
+  nsWindow* popup = mWaylandPopupNext;
+  while (popup) {
+    // Don't check closed popups and drag source popups and tooltips.
+    if (!popup->mPopupClosed && popup->mPopupType != ePopupTypeTooltip &&
+        !popup->mSourceDragContext) {
+      if (!popup->IsPopupInLayoutPopupChain(aLayoutWidgetHierarchy,
+                                            /* aMustMatchParent */ false)) {
+        LOG("  hidding popup [%p]", popup);
+        popup->WaylandPopupMarkAsClosed();
+      }
+    }
+    popup = popup->mWaylandPopupNext;
+  }
+}
+
+// Mark popups outside of layout hierarchy
+void nsWindow::WaylandPopupHierarchyValidateByLayout(
+    nsTArray<nsIWidget*>* aLayoutWidgetHierarchy) {
+  LOG("nsWindow::WaylandPopupHierarchyValidateByLayout");
+  nsWindow* popup = mWaylandPopupNext;
+  while (popup) {
+    if (popup->mPopupType == ePopupTypeTooltip) {
+      popup->mPopupMatchesLayout = true;
+    } else if (!popup->mPopupClosed) {
+      popup->mPopupMatchesLayout = popup->IsPopupInLayoutPopupChain(
+          aLayoutWidgetHierarchy, /* aMustMatchParent */ true);
+      LOG("  popup [%p] parent window [%p] matches layout %d\n", (void*)popup,
+          (void*)popup->mWaylandPopupPrev, popup->mPopupMatchesLayout);
+    }
+    popup = popup->mWaylandPopupNext;
+  }
+}
+
+void nsWindow::WaylandPopupHierarchyHideTemporary() {
+  LOG("nsWindow::WaylandPopupHierarchyHideTemporary()");
+  nsWindow* popup = WaylandPopupFindLast(this);
+  while (popup && popup != this) {
+    LOG("  temporary hidding popup [%p]", popup);
+    nsWindow* prev = popup->mWaylandPopupPrev;
+    popup->HideWaylandPopupWindow(/* aTemporaryHide */ true,
+                                  /* aRemoveFromPopupList */ false);
+    popup = prev;
+  }
+}
+
+void nsWindow::WaylandPopupHierarchyShowTemporaryHidden() {
+  LOG("nsWindow::WaylandPopupHierarchyShowTemporaryHidden()");
+  nsWindow* popup = this;
+  while (popup) {
+    if (popup->mPopupTemporaryHidden) {
+      popup->mPopupTemporaryHidden = false;
+      LOG("  showing temporary hidden popup [%p]", popup);
+      popup->ShowWaylandPopupWindow();
+    }
+    popup = popup->mWaylandPopupNext;
+  }
+}
+
+void nsWindow::WaylandPopupHierarchyCalculatePositions() {
+  LOG("nsWindow::WaylandPopupHierarchyCalculatePositions()");
+
+  // Set widget hierarchy in Gtk
+  nsWindow* popup = mWaylandToplevel->mWaylandPopupNext;
+  while (popup) {
+    LOG("  popup [%p] set parent window [%p]", (void*)popup,
+        (void*)popup->mWaylandPopupPrev);
+    GtkWindowSetTransientFor(GTK_WINDOW(popup->mShell),
+                             GTK_WINDOW(popup->mWaylandPopupPrev->mShell));
+    popup = popup->mWaylandPopupNext;
+  }
+
+  popup = this;
+  while (popup) {
+    // Anchored window has mPopupPosition already calculated against
+    // its parent, no need to recalculate.
+    LOG("  popup [%p] bounds [%d, %d] -> [%d x %d]", popup,
+        (int)(popup->mBounds.x / FractionalScaleFactor()),
+        (int)(popup->mBounds.y / FractionalScaleFactor()),
+        (int)(popup->mBounds.width / FractionalScaleFactor()),
+        (int)(popup->mBounds.height / FractionalScaleFactor()));
+#ifdef MOZ_LOGGING
+    if (LOG_ENABLED()) {
+      if (nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame())) {
+        auto r = LayoutDeviceRect::FromAppUnitsRounded(
+            popupFrame->GetRect(),
+            popupFrame->PresContext()->AppUnitsPerDevPixel());
+        LOG("  popup [%p] layout [%d, %d] -> [%d x %d]", popup, r.x, r.y,
+            r.width, r.height);
+      }
+    }
+#endif
+    if (popup->WaylandPopupIsFirst()) {
+      LOG("  popup [%p] has toplevel as parent", popup);
+      popup->mRelativePopupPosition = popup->mPopupPosition;
+    } else {
+      if (popup->mPopupAnchored) {
+        LOG("  popup [%p] is anchored", popup);
+        if (!popup->mPopupMatchesLayout) {
+          NS_WARNING("Anchored popup does not match layout!");
+        }
+      }
+      GdkPoint parent = popup->WaylandGetParentPosition();
+
+      LOG("  popup [%p] uses transformed coordinates\n", popup);
+      LOG("    parent position [%d, %d]\n", parent.x, parent.y);
+      LOG("    popup position [%d, %d]\n", popup->mPopupPosition.x,
+          popup->mPopupPosition.y);
+
+      popup->mRelativePopupPosition.x = popup->mPopupPosition.x - parent.x;
+      popup->mRelativePopupPosition.y = popup->mPopupPosition.y - parent.y;
+    }
+    LOG("  popup [%p] transformed popup coordinates from [%d, %d] to [%d, %d]",
+        popup, popup->mPopupPosition.x, popup->mPopupPosition.y,
+        popup->mRelativePopupPosition.x, popup->mRelativePopupPosition.y);
+    popup = popup->mWaylandPopupNext;
+  }
+}
+
+// The MenuList popups are used as dropdown menus for example in WebRTC
+// microphone/camera chooser or autocomplete widgets.
+bool nsWindow::WaylandPopupIsMenu() {
+  nsMenuPopupFrame* menuPopupFrame = GetMenuPopupFrame(GetFrame());
+  if (menuPopupFrame) {
+    return mPopupType == ePopupTypeMenu && !menuPopupFrame->IsMenuList();
+  }
+  return false;
+}
+
+bool nsWindow::WaylandPopupIsContextMenu() {
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+  if (!popupFrame) {
+    return false;
+  }
+  return popupFrame->IsContextMenu();
+}
+
+bool nsWindow::WaylandPopupIsPermanent() {
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+  if (!popupFrame) {
+    // We can always hide popups without frames.
+    return false;
+  }
+  return popupFrame->IsNoAutoHide();
+}
+
+bool nsWindow::WaylandPopupIsAnchored() {
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+  if (!popupFrame) {
+    // We can always hide popups without frames.
+    return false;
+  }
+  return !!popupFrame->GetAnchor();
+}
+
+bool nsWindow::IsWidgetOverflowWindow() {
+  if (this->GetFrame() && this->GetFrame()->GetContent()->GetID()) {
+    nsCString nodeId;
+    this->GetFrame()->GetContent()->GetID()->ToUTF8String(nodeId);
+    return nodeId.Equals("widget-overflow");
+  }
+  return false;
+}
+
+bool nsWindow::WaylandPopupIsFirst() {
+  return !mWaylandPopupPrev || !mWaylandPopupPrev->mWaylandToplevel;
+}
+
+nsWindow* nsWindow::GetEffectiveParent() {
+  GtkWindow* parentGtkWindow = gtk_window_get_transient_for(GTK_WINDOW(mShell));
+  if (!parentGtkWindow || !GTK_IS_WIDGET(parentGtkWindow)) {
+    return nullptr;
+  }
+  return get_window_for_gtk_widget(GTK_WIDGET(parentGtkWindow));
+}
+
+GdkPoint nsWindow::WaylandGetParentPosition() {
+  GdkPoint topLeft = {0, 0};
+  nsWindow* window = GetEffectiveParent();
+  if (window->IsPopup()) {
+    topLeft = DevicePixelsToGdkPointRoundDown(window->mBounds.TopLeft());
+  }
+  LOG("nsWindow::WaylandGetParentPosition() [%d, %d]\n", topLeft.x, topLeft.y);
+  return topLeft;
+}
+
+#ifdef MOZ_LOGGING
+void nsWindow::LogPopupHierarchy() {
+  if (!LOG_ENABLED()) {
+    return;
+  }
+
+  LOG("Widget Popup Hierarchy:\n");
+  if (!mWaylandToplevel->mWaylandPopupNext) {
+    LOG("    Empty\n");
+  } else {
+    int indent = 4;
+    nsWindow* popup = mWaylandToplevel->mWaylandPopupNext;
+    while (popup) {
+      nsPrintfCString indentString("%*s", indent, " ");
+      LOG("%s %s %s nsWindow [%p] Menu %d Permanent %d ContextMenu %d "
+          "Anchored %d Visible %d MovedByRect %d\n",
+          indentString.get(), popup->GetFrameTag().get(),
+          popup->GetPopupTypeName().get(), popup, popup->WaylandPopupIsMenu(),
+          popup->WaylandPopupIsPermanent(), popup->mPopupContextMenu,
+          popup->mPopupAnchored, gtk_widget_is_visible(popup->mShell),
+          popup->mPopupUseMoveToRect);
+      indent += 4;
+      popup = popup->mWaylandPopupNext;
+    }
+  }
+
+  LOG("Layout Popup Hierarchy:\n");
+  AutoTArray<nsIWidget*, 5> widgetChain;
+  GetLayoutPopupWidgetChain(&widgetChain);
+  if (widgetChain.Length() == 0) {
+    LOG("    Empty\n");
+  } else {
+    for (unsigned long i = 0; i < widgetChain.Length(); i++) {
+      nsWindow* window = static_cast<nsWindow*>(widgetChain[i]);
+      nsPrintfCString indentString("%*s", (int)(i + 1) * 4, " ");
+      if (window) {
+        LOG("%s %s %s nsWindow [%p] Menu %d Permanent %d ContextMenu %d "
+            "Anchored %d Visible %d MovedByRect %d\n",
+            indentString.get(), window->GetFrameTag().get(),
+            window->GetPopupTypeName().get(), window,
+            window->WaylandPopupIsMenu(), window->WaylandPopupIsPermanent(),
+            window->mPopupContextMenu, window->mPopupAnchored,
+            gtk_widget_is_visible(window->mShell), window->mPopupUseMoveToRect);
+      } else {
+        LOG("%s null window\n", indentString.get());
+      }
+    }
+  }
+}
+#endif
+
+nsWindow* nsWindow::WaylandPopupGetTopmostWindow() {
+  nsView* view = nsView::GetViewFor(this);
+  if (view) {
+    nsView* parentView = view->GetParent();
+    if (parentView) {
+      nsIWidget* parentWidget = parentView->GetNearestWidget(nullptr);
+      if (parentWidget) {
+        nsWindow* parentnsWindow = static_cast<nsWindow*>(parentWidget);
+        LOG("  Topmost window: %p [nsWindow]\n", parentnsWindow);
+        return parentnsWindow;
+      }
+    }
+  }
+  return nullptr;
+}
+
+// Configure Wayland popup. If true is returned we need to track popup
+// in popup hierarchy. Otherwise we just show it as is.
+bool nsWindow::WaylandPopupConfigure() {
+  if (mIsDragPopup) {
+    return false;
+  }
+
+  // Don't track popups without frame
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+  if (!popupFrame) {
+    return false;
+  }
+
+  // Popup state can be changed, see Bug 1728952.
+  bool permanentStateMatches =
+      mPopupTrackInHierarchy == !WaylandPopupIsPermanent();
+
+  // Popup permanent state (noautohide attribute) can change during popup life.
+  if (mPopupTrackInHierarchyConfigured && permanentStateMatches) {
+    return mPopupTrackInHierarchy;
+  }
+
+  // Configure persistent popup params only once.
+  // WaylandPopupIsAnchored() can give it wrong value after
+  // nsMenuPopupFrame::MoveTo() call which we use in move-to-rect callback
+  // to position popup after wayland position change.
+  if (!mPopupTrackInHierarchyConfigured) {
+    mPopupAnchored = WaylandPopupIsAnchored();
+    mPopupContextMenu = WaylandPopupIsContextMenu();
+  }
+
+  LOG("nsWindow::WaylandPopupConfigure tracked %d anchored %d hint %d\n",
+      mPopupTrackInHierarchy, mPopupAnchored, mPopupHint);
+
+  // Permanent state changed and popup is mapped.
+  // We need to switch popup type but that's done when popup is mapped
+  // by Gtk so we need to unmap the popup here.
+  // It will be mapped again by gtk_widget_show().
+  if (!permanentStateMatches && mIsMapped) {
+    LOG("  permanent state change from %d to %d, unmapping",
+        mPopupTrackInHierarchy, !WaylandPopupIsPermanent());
+    gtk_widget_unmap(mShell);
+  }
+
+  mPopupTrackInHierarchy = !WaylandPopupIsPermanent();
+  LOG("  tracked in hierarchy %d\n", mPopupTrackInHierarchy);
+
+  // See gdkwindow-wayland.c and
+  // should_map_as_popup()/should_map_as_subsurface()
+  GdkWindowTypeHint gtkTypeHint;
+  switch (mPopupHint) {
+    case ePopupTypeMenu:
+      // GDK_WINDOW_TYPE_HINT_POPUP_MENU is mapped as xdg_popup by default.
+      // We use this type for all menu popups.
+      gtkTypeHint = GDK_WINDOW_TYPE_HINT_POPUP_MENU;
+      LOG("  popup type Menu");
+      break;
+    case ePopupTypeTooltip:
+      gtkTypeHint = GDK_WINDOW_TYPE_HINT_TOOLTIP;
+      LOG("  popup type Tooltip");
+      break;
+    default:
+      gtkTypeHint = GDK_WINDOW_TYPE_HINT_UTILITY;
+      LOG("  popup type Utility");
+      break;
+  }
+
+  if (!mPopupTrackInHierarchy) {
+    // GDK_WINDOW_TYPE_HINT_UTILITY is mapped as wl_subsurface
+    // by default.
+    LOG("  not tracked in popup hierarchy, switch to Utility");
+    gtkTypeHint = GDK_WINDOW_TYPE_HINT_UTILITY;
+  }
+  gtk_window_set_type_hint(GTK_WINDOW(mShell), gtkTypeHint);
+
+  mPopupTrackInHierarchyConfigured = true;
+  return mPopupTrackInHierarchy;
+}
+
+bool nsWindow::IsInPopupHierarchy() {
+  return mPopupTrackInHierarchy && mWaylandToplevel && mWaylandPopupPrev;
+}
+
+void nsWindow::AddWindowToPopupHierarchy() {
+  LOG("nsWindow::AddWindowToPopupHierarchy\n");
+  if (!GetFrame()) {
+    LOG("  Window without frame cannot be added as popup!\n");
+    return;
+  }
+
+  // Check if we're already in the hierarchy
+  if (!IsInPopupHierarchy()) {
+    mWaylandToplevel = WaylandPopupGetTopmostWindow();
+    AppendPopupToHierarchyList(mWaylandToplevel);
+  }
+}
+
+// Wayland keeps strong popup window hierarchy. We need to track active
+// (visible) popup windows and make sure we hide popup on the same level
+// before we open another one on that level. It means that every open
+// popup needs to have an unique parent.
+void nsWindow::UpdateWaylandPopupHierarchy() {
+  LOG("nsWindow::UpdateWaylandPopupHierarchy\n");
+
+  // This popup hasn't been added to popup hierarchy yet so no need to
+  // do any configurations.
+  if (!IsInPopupHierarchy()) {
+    LOG("  popup isn't in hierarchy\n");
+    return;
+  }
+
+#ifdef MOZ_LOGGING
+  LogPopupHierarchy();
+  auto printPopupHierarchy = MakeScopeExit([&] { LogPopupHierarchy(); });
+#endif
+
+  // Hide all tooltips without the last one. Tooltip can't be popup parent.
+  mWaylandToplevel->WaylandPopupHideTooltips();
+
+  // See Bug 1709254 / https://gitlab.gnome.org/GNOME/gtk/-/issues/5092
+  // It's possible that Wayland compositor refuses to show
+  // a popup although Gtk claims it's visible.
+  // We don't know if the popup is shown or not.
+  // To avoid application crash refuse to create any child of such invisible
+  // popup and close any child of it now.
+  mWaylandToplevel->WaylandPopupCloseOrphanedPopups();
+
+  // Check if we have any remote content / overflow window in hierarchy.
+  // We can't attach such widget on top of other popup.
+  mWaylandToplevel->CloseAllPopupsBeforeRemotePopup();
+
+  // Check if your popup hierarchy matches layout hierarchy.
+  // For instance we should not connect hamburger menu on top
+  // of context menu.
+  // Close all popups from different layout chains if possible.
+  AutoTArray<nsIWidget*, 5> layoutPopupWidgetChain;
+  GetLayoutPopupWidgetChain(&layoutPopupWidgetChain);
+
+  mWaylandToplevel->WaylandPopupHierarchyHideByLayout(&layoutPopupWidgetChain);
+  mWaylandToplevel->WaylandPopupHierarchyValidateByLayout(
+      &layoutPopupWidgetChain);
+
+  // Now we have Popup hierarchy complete.
+  // Find first unchanged (and still open) popup to start with hierarchy
+  // changes.
+  nsWindow* changedPopup = mWaylandToplevel->mWaylandPopupNext;
+  while (changedPopup) {
+    // Stop when parent of this popup was changed and we need to recalc
+    // popup position.
+    if (changedPopup->mPopupChanged) {
+      break;
+    }
+    // Stop when this popup is closed.
+    if (changedPopup->mPopupClosed) {
+      break;
+    }
+    changedPopup = changedPopup->mWaylandPopupNext;
+  }
+
+  // We don't need to recompute popup positions, quit now.
+  if (!changedPopup) {
+    LOG("  changed Popup is null, quit.\n");
+    return;
+  }
+
+  LOG("  first changed popup [%p]\n", (void*)changedPopup);
+
+  // Hide parent popups if necessary (there are layout discontinuity)
+  // reposition the popup and show them again.
+  changedPopup->WaylandPopupHierarchyHideTemporary();
+
+  nsWindow* parentOfchangedPopup = nullptr;
+  if (changedPopup->mPopupClosed) {
+    parentOfchangedPopup = changedPopup->mWaylandPopupPrev;
+  }
+  changedPopup->WaylandPopupRemoveClosedPopups();
+
+  // It's possible that changedPopup was removed from widget hierarchy,
+  // in such case use child popup of the removed one if there's any.
+  if (!changedPopup->IsInPopupHierarchy()) {
+    if (!parentOfchangedPopup || !parentOfchangedPopup->mWaylandPopupNext) {
+      LOG("  last popup was removed, quit.\n");
+      return;
+    }
+    changedPopup = parentOfchangedPopup->mWaylandPopupNext;
+  }
+
+  GetLayoutPopupWidgetChain(&layoutPopupWidgetChain);
+  mWaylandToplevel->WaylandPopupHierarchyValidateByLayout(
+      &layoutPopupWidgetChain);
+
+  changedPopup->WaylandPopupHierarchyCalculatePositions();
+
+  nsWindow* popup = changedPopup;
+  while (popup) {
+    const bool useMoveToRect = [&] {
+      if (!StaticPrefs::widget_wayland_use_move_to_rect_AtStartup()) {
+        return false;  // Not available.
+      }
+      if (!popup->mPopupMatchesLayout) {
+        // We can use move_to_rect only when popups in popup hierarchy matches
+        // layout hierarchy as move_to_rect request that parent/child
+        // popups are adjacent.
+        return false;
+      }
+      if (popup->mPopupHint == ePopupTypePanel &&
+          popup->WaylandPopupIsFirst() &&
+          popup->WaylandPopupFitsToplevelWindow(/* aMove */ true)) {
+        // Workaround for https://gitlab.gnome.org/GNOME/gtk/-/issues/1986
+        //
+        // ePopupTypePanel types are used for extension popups which may be
+        // resized. If such popup uses move-to-rect, we need to hide it before
+        // resize and show it again. That leads to massive flickering
+        // so use plain move if possible to avoid it.
+        //
+        // Bug 1760276 - don't use move-to-rect when popup is inside main
+        // Firefox window.
+        //
+        // Use it for first popups only due to another mutter bug
+        // https://gitlab.gnome.org/GNOME/gtk/-/issues/5089
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1784873
+        return false;
+      }
+      if (!popup->WaylandPopupIsFirst() &&
+          !popup->mWaylandPopupPrev->WaylandPopupIsFirst() &&
+          !popup->mWaylandPopupPrev->mPopupUseMoveToRect) {
+        // We can't use move-to-rect if there are more parents of
+        // wl_subsurface popups types.
+        //
+        // It's because wl_subsurface is ignored by xgd_popup
+        // (created by move-to-rect) so our popup scenario:
+        //
+        // toplevel -> xgd_popup(1) -> wl_subsurface(2) -> xgd_popup(3)
+        //
+        // looks for Wayland compositor as:
+        //
+        // toplevel -> xgd_popup(1) -> xgd_popup(3)
+        //
+        // If xgd_popup(1) and xgd_popup(3) are not connected
+        // move-to-rect applied to xgd_popup(3) fails and we get missing popup.
+        return false;
+      }
+      return true;
+    }();
+
+    LOG("  popup [%p] matches layout [%d] anchored [%d] first popup [%d] use "
+        "move-to-rect %d\n",
+        popup, popup->mPopupMatchesLayout, popup->mPopupAnchored,
+        popup->WaylandPopupIsFirst(), useMoveToRect);
+
+    popup->mPopupUseMoveToRect = useMoveToRect;
+    popup->WaylandPopupMoveImpl();
+    popup->mPopupChanged = false;
+    popup = popup->mWaylandPopupNext;
+  }
+
+  changedPopup->WaylandPopupHierarchyShowTemporaryHidden();
+}
+
+static void NativeMoveResizeCallback(GdkWindow* window,
+                                     const GdkRectangle* flipped_rect,
+                                     const GdkRectangle* final_rect,
+                                     gboolean flipped_x, gboolean flipped_y,
+                                     void* aWindow) {
+  LOG_POPUP("[%p] NativeMoveResizeCallback flipped_x %d flipped_y %d\n",
+            aWindow, flipped_x, flipped_y);
+  LOG_POPUP("[%p]    new position [%d, %d] -> [%d x %d]", aWindow,
+            final_rect->x, final_rect->y, final_rect->width,
+            final_rect->height);
+  nsWindow* wnd = get_window_for_gdk_window(window);
+
+  wnd->NativeMoveResizeWaylandPopupCallback(final_rect, flipped_x, flipped_y);
+}
+
+// When popup is repositioned by widget code, we need to notify
+// layout about it. It's because we control popup placement
+// on widget on Wayland so layout may have old popup size/coordinates.
+void nsWindow::WaylandPopupPropagateChangesToLayout(bool aMove, bool aResize) {
+  LOG("nsWindow::WaylandPopupPropagateChangesToLayout()");
+
+  if (aResize) {
+    LOG("  needSizeUpdate\n");
+    if (nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame())) {
+      RefPtr<PresShell> presShell = popupFrame->PresShell();
+      presShell->FrameNeedsReflow(popupFrame, IntrinsicDirty::None,
+                                  NS_FRAME_IS_DIRTY);
+    }
+  }
+  if (aMove) {
+    LOG("  needPositionUpdate, bounds [%d, %d]", mBounds.x, mBounds.y);
+    NotifyWindowMoved(mBounds.x, mBounds.y, ByMoveToRect::Yes);
+  }
+}
+
+void nsWindow::NativeMoveResizeWaylandPopupCallback(
+    const GdkRectangle* aFinalSize, bool aFlippedX, bool aFlippedY) {
+  // We're getting move-to-rect callback without move-to-rect call.
+  // That indicates a compositor bug. It happens when a window is hidden and
+  // shown again before move-to-rect callback is fired.
+  // It may lead to incorrect popup placement as we may call
+  // gtk_window_move() between hide & show.
+  // See Bug 1777919, 1789581.
+#if MOZ_LOGGING
+  if (!mWaitingForMoveToRectCallback) {
+    LOG("  Bogus move-to-rect callback! Expect wrong popup coordinates.");
+  }
+#endif
+
+  mWaitingForMoveToRectCallback = false;
+
+  bool movedByLayout = mMovedAfterMoveToRect;
+  bool resizedByLayout = mResizedAfterMoveToRect;
+
+  // Popup was moved between move-to-rect call and move-to-rect callback
+  // and the coordinates from move-to-rect callback are outdated.
+  if (movedByLayout || resizedByLayout) {
+    LOG("  Another move/resize called during waiting for callback\n");
+    mMovedAfterMoveToRect = false;
+    mResizedAfterMoveToRect = false;
+    // Fire another round of move/resize to reflect latest request
+    // from layout.
+    NativeMoveResize(movedByLayout, resizedByLayout);
+    return;
+  }
+
+  LOG("  orig mBounds [%d, %d] -> [%d x %d]\n", mBounds.x, mBounds.y,
+      mBounds.width, mBounds.height);
+
+  LayoutDeviceIntRect newBounds = [&] {
+    GdkRectangle finalRect = *aFinalSize;
+    GdkPoint parent = WaylandGetParentPosition();
+    finalRect.x += parent.x;
+    finalRect.y += parent.y;
+    return GdkRectToDevicePixels(finalRect);
+  }();
+
+  LOG("  new mBounds [%d, %d] -> [%d x %d]", newBounds.x, newBounds.y,
+      newBounds.width, newBounds.height);
+
+  bool needsPositionUpdate = newBounds.TopLeft() != mBounds.TopLeft();
+  bool needsSizeUpdate = newBounds.Size() != mLastSizeRequest;
+
+  if (needsSizeUpdate) {
+    // Wayland compositor changed popup size request from layout.
+    // Set the constraints to use them in nsMenuPopupFrame::SetPopupPosition().
+    // Beware that gtk_window_resize() requests sizes asynchronously and so
+    // newBounds might not have the size from the most recent
+    // gtk_window_resize().
+    if (newBounds.width < mLastSizeRequest.width) {
+      mMoveToRectPopupSize.width = newBounds.width;
+    }
+    if (newBounds.height < mLastSizeRequest.height) {
+      mMoveToRectPopupSize.height = newBounds.height;
+    }
+    LOG("  mMoveToRectPopupSize set to [%d, %d]", mMoveToRectPopupSize.width,
+        mMoveToRectPopupSize.height);
+  }
+  mBounds = newBounds;
+  // Check mBounds size
+  if (mCompositorSession &&
+      !wr::WindowSizeSanityCheck(mBounds.width, mBounds.height)) {
+    gfxCriticalNoteOnce << "Invalid mBounds in PopupCallback " << mBounds
+                        << " size state " << mSizeMode;
+  }
+  WaylandPopupPropagateChangesToLayout(needsPositionUpdate, needsSizeUpdate);
+}
+
+static GdkGravity PopupAlignmentToGdkGravity(int8_t aAlignment) {
+  switch (aAlignment) {
+    case POPUPALIGNMENT_NONE:
+      return GDK_GRAVITY_NORTH_WEST;
+    case POPUPALIGNMENT_TOPLEFT:
+      return GDK_GRAVITY_NORTH_WEST;
+    case POPUPALIGNMENT_TOPRIGHT:
+      return GDK_GRAVITY_NORTH_EAST;
+    case POPUPALIGNMENT_BOTTOMLEFT:
+      return GDK_GRAVITY_SOUTH_WEST;
+    case POPUPALIGNMENT_BOTTOMRIGHT:
+      return GDK_GRAVITY_SOUTH_EAST;
+    case POPUPALIGNMENT_LEFTCENTER:
+      return GDK_GRAVITY_WEST;
+    case POPUPALIGNMENT_RIGHTCENTER:
+      return GDK_GRAVITY_EAST;
+    case POPUPALIGNMENT_TOPCENTER:
+      return GDK_GRAVITY_NORTH;
+    case POPUPALIGNMENT_BOTTOMCENTER:
+      return GDK_GRAVITY_SOUTH;
+  }
+  return GDK_GRAVITY_STATIC;
+}
+
+bool nsWindow::IsPopupDirectionRTL() {
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+  return popupFrame && popupFrame->IsDirectionRTL();
+}
+
+// Position the popup directly by gtk_window_move() and try to keep it
+// on screen by just moving it in scope of it's parent window.
+//
+// It's used when we position noautihode popup and we don't use xdg_positioner.
+// See Bug 1718867
+void nsWindow::WaylandPopupSetDirectPosition() {
+  GdkPoint topLeft = DevicePixelsToGdkPointRoundDown(mBounds.TopLeft());
+  GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mLastSizeRequest);
+
+  LOG("nsWindow::WaylandPopupSetDirectPosition %d,%d -> %d x %d\n", topLeft.x,
+      topLeft.y, size.width, size.height);
+
+  mPopupPosition = {topLeft.x, topLeft.y};
+
+  if (mIsDragPopup) {
+    gtk_window_move(GTK_WINDOW(mShell), topLeft.x, topLeft.y);
+    gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
+    // DND window is placed inside container so we need to make hard size
+    // request to ensure parent container is resized too.
+    gtk_widget_set_size_request(GTK_WIDGET(mShell), size.width, size.height);
+    return;
+  }
+
+  GtkWindow* parentGtkWindow = gtk_window_get_transient_for(GTK_WINDOW(mShell));
+  nsWindow* window = get_window_for_gtk_widget(GTK_WIDGET(parentGtkWindow));
+  if (!window) {
+    return;
+  }
+  GdkWindow* gdkWindow =
+      gtk_widget_get_window(GTK_WIDGET(window->GetMozContainer()));
+
+  int parentWidth = gdk_window_get_width(gdkWindow);
+  int popupWidth = size.width;
+
+  int x;
+  gdk_window_get_position(gdkWindow, &x, nullptr);
+
+  // If popup is bigger than main window just center it.
+  if (popupWidth > parentWidth) {
+    mPopupPosition.x = -(parentWidth - popupWidth) / 2 + x;
+  } else {
+    if (IsPopupDirectionRTL()) {
+      // Stick with right window edge
+      if (mPopupPosition.x < x) {
+        mPopupPosition.x = x;
+      }
+    } else {
+      // Stick with left window edge
+      if (mPopupPosition.x + popupWidth > parentWidth + x) {
+        mPopupPosition.x = parentWidth + x - popupWidth;
+      }
+    }
+  }
+
+  LOG("  set position [%d, %d]\n", mPopupPosition.x, mPopupPosition.y);
+  gtk_window_move(GTK_WINDOW(mShell), mPopupPosition.x, mPopupPosition.y);
+
+  LOG("  set size [%d, %d]\n", size.width, size.height);
+  gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
+
+  if (mPopupPosition.x != topLeft.x) {
+    mBounds.MoveTo(GdkPointToDevicePixels(mPopupPosition));
+    LOG("  setting new bounds [%d, %d]\n", mBounds.x, mBounds.y);
+    WaylandPopupPropagateChangesToLayout(/* move */ true, /* resize */ false);
+  }
+}
+
+bool nsWindow::WaylandPopupFitsToplevelWindow(bool aMove) {
+  LOG("nsWindow::WaylandPopupFitsToplevelWindow() move %d", aMove);
+
+  GtkWindow* parent = gtk_window_get_transient_for(GTK_WINDOW(mShell));
+  GtkWindow* tmp = parent;
+  while ((tmp = gtk_window_get_transient_for(GTK_WINDOW(parent)))) {
+    parent = tmp;
+  }
+  GdkWindow* toplevelGdkWindow = gtk_widget_get_window(GTK_WIDGET(parent));
+
+  if (!toplevelGdkWindow) {
+    NS_WARNING("Toplevel widget without GdkWindow?");
+    return false;
+  }
+
+  int parentWidth = gdk_window_get_width(toplevelGdkWindow);
+  int parentHeight = gdk_window_get_height(toplevelGdkWindow);
+  LOG("  parent size %d x %d", parentWidth, parentHeight);
+
+  GdkPoint topLeft = aMove ? mPopupPosition
+                           : DevicePixelsToGdkPointRoundDown(mBounds.TopLeft());
+  GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mLastSizeRequest);
+  LOG("  popup topleft %d, %d size %d x %d", topLeft.x, topLeft.y, size.width,
+      size.height);
+  int fits = topLeft.x >= 0 && topLeft.y >= 0 &&
+             topLeft.x + size.width <= parentWidth &&
+             topLeft.y + size.height <= parentHeight;
+
+  LOG("  fits %d", fits);
+  return fits;
+}
+
+void nsWindow::NativeMoveResizeWaylandPopup(bool aMove, bool aResize) {
+  GdkPoint topLeft = DevicePixelsToGdkPointRoundDown(mBounds.TopLeft());
+  GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mLastSizeRequest);
+
+  LOG("nsWindow::NativeMoveResizeWaylandPopup Bounds %d,%d -> %d x %d move %d "
+      "resize %d\n",
+      topLeft.x, topLeft.y, size.width, size.height, aMove, aResize);
+
+  // Compositor may be confused by windows with width/height = 0
+  // and positioning such windows leads to Bug 1555866.
+  if (!AreBoundsSane()) {
+    LOG("  Bounds are not sane (width: %d height: %d)\n",
+        mLastSizeRequest.width, mLastSizeRequest.height);
+    return;
+  }
+
+  if (mWaitingForMoveToRectCallback) {
+    LOG("  waiting for move to rect, scheduling");
+    // mBounds position must not be overwritten before it is applied.
+    // OnConfigureEvent() will not set mBounds to an old position for
+    // GTK_WINDOW_POPUP.
+    MOZ_ASSERT(gtk_window_get_window_type(GTK_WINDOW(mShell)) ==
+               GTK_WINDOW_POPUP);
+    mMovedAfterMoveToRect = aMove;
+    mResizedAfterMoveToRect = aResize;
+    return;
+  }
+
+  mMovedAfterMoveToRect = false;
+  mResizedAfterMoveToRect = false;
+
+  bool trackedInHierarchy = WaylandPopupConfigure();
+
+  // Read popup position from layout if it was moved or newly created.
+  // This position is used by move-to-rect method as we need anchor and other
+  // info to place popup correctly.
+  // We need WaylandPopupConfigure() to be called before to have all needed
+  // popup info in place (mainly the anchored flag).
+  if (aMove) {
+    mPopupMoveToRectParams = WaylandPopupGetPositionFromLayout();
+  }
+
+  if (!trackedInHierarchy) {
+    WaylandPopupSetDirectPosition();
+    return;
+  }
+
+  if (aResize) {
+    LOG("  set size [%d, %d]\n", size.width, size.height);
+    gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
+  }
+
+  if (!aMove && WaylandPopupFitsToplevelWindow(aMove)) {
+    // Popup position has not been changed and its position/size fits
+    // parent window so no need to reposition the window.
+    LOG("  fits parent window size, just resize\n");
+    return;
+  }
+
+  // Mark popup as changed as we're updating position/size.
+  mPopupChanged = true;
+
+  // Save popup position for former re-calculations when popup hierarchy
+  // is changed.
+  LOG("  popup position changed from [%d, %d] to [%d, %d]\n", mPopupPosition.x,
+      mPopupPosition.y, topLeft.x, topLeft.y);
+  mPopupPosition = {topLeft.x, topLeft.y};
+
+  UpdateWaylandPopupHierarchy();
+}
+
+struct PopupSides {
+  Maybe<Side> mVertical;
+  Maybe<Side> mHorizontal;
+};
+
+static PopupSides SidesForPopupAlignment(int8_t aAlignment) {
+  switch (aAlignment) {
+    case POPUPALIGNMENT_NONE:
+      break;
+    case POPUPALIGNMENT_TOPLEFT:
+      return {Some(eSideTop), Some(eSideLeft)};
+    case POPUPALIGNMENT_TOPRIGHT:
+      return {Some(eSideTop), Some(eSideRight)};
+    case POPUPALIGNMENT_BOTTOMLEFT:
+      return {Some(eSideBottom), Some(eSideLeft)};
+    case POPUPALIGNMENT_BOTTOMRIGHT:
+      return {Some(eSideBottom), Some(eSideRight)};
+    case POPUPALIGNMENT_LEFTCENTER:
+      return {Nothing(), Some(eSideLeft)};
+    case POPUPALIGNMENT_RIGHTCENTER:
+      return {Nothing(), Some(eSideRight)};
+    case POPUPALIGNMENT_TOPCENTER:
+      return {Some(eSideTop), Nothing()};
+    case POPUPALIGNMENT_BOTTOMCENTER:
+      return {Some(eSideBottom), Nothing()};
+  }
+  return {};
+}
+
+// We want to apply margins based on popup alignment (which would generally be
+// just an offset to apply to the popup). However, to deal with flipping
+// correctly, we apply the margin to the anchor when possible.
+struct ResolvedPopupMargin {
+  // A margin to be applied to the anchor.
+  nsMargin mAnchorMargin;
+  // An offset in app units to be applied to the popup for when we need to tell
+  // GTK to center inside the anchor precisely (so we can't really do better in
+  // presence of flips).
+  nsPoint mPopupOffset;
+};
+
+static ResolvedPopupMargin ResolveMargin(nsMenuPopupFrame* aFrame,
+                                         int8_t aPopupAlign,
+                                         int8_t aAnchorAlign,
+                                         bool aAnchoredToPoint,
+                                         bool aIsContextMenu) {
+  nsMargin margin = aFrame->GetMargin();
+  nsPoint offset;
+
+  if (aAnchoredToPoint) {
+    // Since GTK doesn't allow us to specify margins itself, when anchored to a
+    // point we can just assume we'll be aligned correctly... This is kind of
+    // annoying but alas.
+    //
+    // This calculation must match the relevant unanchored popup calculation in
+    // nsMenuPopupFrame::SetPopupPosition(), which should itself be the inverse
+    // inverse of nsMenuPopupFrame::MoveTo().
+    if (aIsContextMenu && aFrame->IsDirectionRTL()) {
+      offset.x = -margin.right;
+    } else {
+      offset.x = margin.left;
+    }
+    offset.y = margin.top;
+    return {nsMargin(), offset};
+  }
+
+  auto popupSides = SidesForPopupAlignment(aPopupAlign);
+  auto anchorSides = SidesForPopupAlignment(aAnchorAlign);
+  // Matched sides: Invert the margin, so that we pull in the right direction.
+  // Popup not aligned to any anchor side: We give up and use the offset,
+  // applying the margin from the popup side.
+  // Mismatched sides: We swap the margins so that we pull in the right
+  // direction, e.g. margin-left: -10px should shrink 10px the _right_ of the
+  // box, not the left of the box.
+  if (popupSides.mHorizontal == anchorSides.mHorizontal) {
+    margin.left = -margin.left;
+    margin.right = -margin.right;
+  } else if (!anchorSides.mHorizontal) {
+    auto popupSide = *popupSides.mHorizontal;
+    offset.x += popupSide == eSideRight ? -margin.Side(popupSide)
+                                        : margin.Side(popupSide);
+    margin.left = margin.right = 0;
+  } else {
+    std::swap(margin.left, margin.right);
+  }
+
+  // Same logic as above, but in the vertical direction.
+  if (popupSides.mVertical == anchorSides.mVertical) {
+    margin.top = -margin.top;
+    margin.bottom = -margin.bottom;
+  } else if (!anchorSides.mVertical) {
+    auto popupSide = *popupSides.mVertical;
+    offset.y += popupSide == eSideBottom ? -margin.Side(popupSide)
+                                         : margin.Side(popupSide);
+    margin.top = margin.bottom = 0;
+  } else {
+    std::swap(margin.top, margin.bottom);
+  }
+
+  return {margin, offset};
+}
+
+#ifdef MOZ_LOGGING
+void nsWindow::LogPopupAnchorHints(int aHints) {
+  static struct hints_ {
+    int hint;
+    char name[100];
+  } hints[] = {
+      {GDK_ANCHOR_FLIP_X, "GDK_ANCHOR_FLIP_X"},
+      {GDK_ANCHOR_FLIP_Y, "GDK_ANCHOR_FLIP_Y"},
+      {GDK_ANCHOR_SLIDE_X, "GDK_ANCHOR_SLIDE_X"},
+      {GDK_ANCHOR_SLIDE_Y, "GDK_ANCHOR_SLIDE_Y"},
+      {GDK_ANCHOR_RESIZE_X, "GDK_ANCHOR_RESIZE_X"},
+      {GDK_ANCHOR_RESIZE_Y, "GDK_ANCHOR_RESIZE_X"},
+  };
+
+  LOG("  PopupAnchorHints");
+  for (const auto& hint : hints) {
+    if (hint.hint & aHints) {
+      LOG("    %s", hint.name);
+    }
+  }
+}
+
+void nsWindow::LogPopupGravity(GdkGravity aGravity) {
+  static char gravity[][100]{"NONE",
+                             "GDK_GRAVITY_NORTH_WEST",
+                             "GDK_GRAVITY_NORTH",
+                             "GDK_GRAVITY_NORTH_EAST",
+                             "GDK_GRAVITY_WEST",
+                             "GDK_GRAVITY_CENTER",
+                             "GDK_GRAVITY_EAST",
+                             "GDK_GRAVITY_SOUTH_WEST",
+                             "GDK_GRAVITY_SOUTH",
+                             "GDK_GRAVITY_SOUTH_EAST",
+                             "GDK_GRAVITY_STATIC"};
+  LOG("    %s", gravity[aGravity]);
+}
+#endif
+
+const nsWindow::WaylandPopupMoveToRectParams
+nsWindow::WaylandPopupGetPositionFromLayout() {
+  LOG("nsWindow::WaylandPopupGetPositionFromLayout\n");
+
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+
+  const bool isTopContextMenu = mPopupContextMenu && !mPopupAnchored;
+  const bool isRTL = IsPopupDirectionRTL();
+  int8_t popupAlign(popupFrame->GetPopupAlignment());
+  int8_t anchorAlign(popupFrame->GetPopupAnchor());
+  if (isTopContextMenu) {
+    anchorAlign = POPUPALIGNMENT_BOTTOMRIGHT;
+    popupAlign = POPUPALIGNMENT_TOPLEFT;
+  }
+  if (isRTL) {
+    popupAlign = -popupAlign;
+    anchorAlign = -anchorAlign;
+  }
+
+  // Although we have mPopupPosition / mRelativePopupPosition here
+  // we can't use it. move-to-rect needs anchor rectangle to position a popup
+  // but we have only a point from Resize().
+  //
+  // So we need to extract popup position from nsMenuPopupFrame() and duplicate
+  // the layout work here.
+  LayoutDeviceIntRect anchorRect;
+  ResolvedPopupMargin popupMargin;
+  {
+    nsRect anchorRectAppUnits = popupFrame->GetUntransformedAnchorRect();
+    // This is a somewhat hacky way of applying the popup margin. We don't know
+    // if GTK will end up flipping the popup, in which case the offset we
+    // compute is just wrong / applied to the wrong side.
+    //
+    // Instead, we tell it to anchor us at a smaller or bigger rect depending on
+    // the margin, which achieves the same result if the popup is positioned
+    // correctly, but doesn't misposition the popup when flipped across the
+    // anchor.
+    popupMargin = ResolveMargin(popupFrame, popupAlign, anchorAlign,
+                                anchorRectAppUnits.IsEmpty(), isTopContextMenu);
+    LOG("  layout popup CSS anchor (%d, %d) %s, margin %s offset %s\n",
+        popupAlign, anchorAlign, ToString(anchorRectAppUnits).c_str(),
+        ToString(popupMargin.mAnchorMargin).c_str(),
+        ToString(popupMargin.mPopupOffset).c_str());
+    anchorRectAppUnits.Inflate(popupMargin.mAnchorMargin);
+    LOG("    after margins %s\n", ToString(anchorRectAppUnits).c_str());
+    nscoord auPerDev = popupFrame->PresContext()->AppUnitsPerDevPixel();
+    anchorRect = LayoutDeviceIntRect::FromAppUnitsToNearest(anchorRectAppUnits,
+                                                            auPerDev);
+    if (anchorRect.width < 0) {
+      auto w = -anchorRect.width;
+      anchorRect.width += w + 1;
+      anchorRect.x += w;
+    }
+    LOG("    final %s\n", ToString(anchorRect).c_str());
+  }
+
+  LOG("  relative popup rect position [%d, %d] -> [%d x %d]\n", anchorRect.x,
+      anchorRect.y, anchorRect.width, anchorRect.height);
+
+  // Get gravity and flip type
+  GdkGravity rectAnchor = PopupAlignmentToGdkGravity(anchorAlign);
+  GdkGravity menuAnchor = PopupAlignmentToGdkGravity(popupAlign);
+
+  LOG("  parentRect gravity: %d anchor gravity: %d\n", rectAnchor, menuAnchor);
+
+  // Gtk default is: GDK_ANCHOR_FLIP | GDK_ANCHOR_SLIDE | GDK_ANCHOR_RESIZE.
+  // We want to SLIDE_X menu on the dual monitor setup rather than resize it
+  // on the other monitor.
+  GdkAnchorHints hints =
+      GdkAnchorHints(GDK_ANCHOR_FLIP | GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_RESIZE);
+
+  // slideHorizontal from nsMenuPopupFrame::SetPopupPosition
+  int8_t position = popupFrame->GetAlignmentPosition();
+  if (position >= POPUPPOSITION_BEFORESTART &&
+      position <= POPUPPOSITION_AFTEREND) {
+    hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE_X);
+  }
+  // slideVertical from nsMenuPopupFrame::SetPopupPosition
+  if (position >= POPUPPOSITION_STARTBEFORE &&
+      position <= POPUPPOSITION_ENDAFTER) {
+    hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE_Y);
+  }
+
+  FlipType flipType = popupFrame->GetFlipType();
+  if (rectAnchor == GDK_GRAVITY_CENTER && menuAnchor == GDK_GRAVITY_CENTER) {
+    // only slide
+    hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE);
+  } else {
+    switch (flipType) {
+      case FlipType_Both:
+        hints = GdkAnchorHints(hints | GDK_ANCHOR_FLIP);
+        break;
+      case FlipType_Slide:
+        hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE);
+        break;
+      case FlipType_Default:
+        hints = GdkAnchorHints(hints | GDK_ANCHOR_FLIP);
+        break;
+      default:
+        break;
+    }
+  }
+  if (!WaylandPopupIsMenu()) {
+    // we don't want to slide menus to fit the screen rather resize them
+    hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE);
+  }
+
+  // We want tooltips to flip verticaly or slide only.
+  // See nsMenuPopupFrame::SetPopupPosition().
+  // https://searchfox.org/mozilla-central/rev/d0f5bc50aff3462c9d1546b88d60c5cb020eb15c/layout/xul/nsMenuPopupFrame.cpp#1603
+  if (mPopupType == ePopupTypeTooltip) {
+    hints = GdkAnchorHints(GDK_ANCHOR_FLIP_Y | GDK_ANCHOR_SLIDE);
+  }
+
+  return {
+      anchorRect,
+      rectAnchor,
+      menuAnchor,
+      hints,
+      DevicePixelsToGdkPointRoundDown(LayoutDevicePoint::FromAppUnitsToNearest(
+          popupMargin.mPopupOffset,
+          popupFrame->PresContext()->AppUnitsPerDevPixel())),
+      true};
+}
+
+bool nsWindow::WaylandPopupAnchorAdjustForParentPopup(
+    GdkRectangle* aPopupAnchor, GdkPoint* aOffset) {
+  LOG("nsWindow::WaylandPopupAnchorAdjustForParentPopup");
+
+  GtkWindow* parentGtkWindow = gtk_window_get_transient_for(GTK_WINDOW(mShell));
+  if (!parentGtkWindow || !GTK_IS_WIDGET(parentGtkWindow)) {
+    NS_WARNING("Popup has no parent!");
+    return false;
+  }
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(parentGtkWindow));
+  if (!window) {
+    NS_WARNING("Popup parrent is not mapped!");
+    return false;
+  }
+
+  GdkRectangle parentWindowRect = {0, 0, gdk_window_get_width(window),
+                                   gdk_window_get_height(window)};
+  LOG("  parent window size %d x %d", parentWindowRect.width,
+      parentWindowRect.height);
+
+  // We can't have rectangle anchor with zero width/height.
+  if (!aPopupAnchor->width) {
+    aPopupAnchor->width = 1;
+  }
+  if (!aPopupAnchor->height) {
+    aPopupAnchor->height = 1;
+  }
+
+  GdkRectangle finalRect;
+  if (!gdk_rectangle_intersect(aPopupAnchor, &parentWindowRect, &finalRect)) {
+    return false;
+  }
+  *aPopupAnchor = finalRect;
+  LOG("  anchor is correct %d,%d -> %d x %d", finalRect.x, finalRect.y,
+      finalRect.width, finalRect.height);
+
+  *aOffset = mPopupMoveToRectParams.mOffset;
+  LOG("  anchor offset %d, %d", aOffset->x, aOffset->y);
+  return true;
+}
+
+bool nsWindow::WaylandPopupCheckAndGetAnchor(GdkRectangle* aPopupAnchor,
+                                             GdkPoint* aOffset) {
+  LOG("nsWindow::WaylandPopupCheckAndGetAnchor");
+
+  GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(mShell));
+  nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame());
+  if (!gdkWindow || !popupFrame) {
+    LOG("  can't use move-to-rect due missing gdkWindow or popupFrame");
+    return false;
+  }
+  if (!mPopupMoveToRectParams.mAnchorSet) {
+    LOG("  can't use move-to-rect due missing anchor");
+    return false;
+  }
+  // Update popup layout coordinates from layout by recent popup hierarchy
+  // (calculate correct position according to parent window)
+  // and convert to Gtk coordinates.
+  LayoutDeviceIntRect anchorRect = mPopupMoveToRectParams.mAnchorRect;
+  if (!WaylandPopupIsFirst()) {
+    GdkPoint parent = WaylandGetParentPosition();
+    LOG("  subtract parent position from anchor [%d, %d]\n", parent.x,
+        parent.y);
+    anchorRect.MoveBy(-GdkPointToDevicePixels(parent));
+  }
+
+  *aPopupAnchor = DevicePixelsToGdkRectRoundOut(anchorRect);
+  LOG("  anchored to rectangle [%d, %d] -> [%d x %d]", aPopupAnchor->x,
+      aPopupAnchor->y, aPopupAnchor->width, aPopupAnchor->height);
+
+  if (!WaylandPopupAnchorAdjustForParentPopup(aPopupAnchor, aOffset)) {
+    LOG("  can't use move-to-rect, anchor is not placed inside of parent "
+        "window");
+    return false;
+  }
+
+  return true;
+}
+
+void nsWindow::WaylandPopupPrepareForMove() {
+  LOG("nsWindow::WaylandPopupPrepareForMove()");
+
+  if (mPopupHint == ePopupTypeTooltip) {
+    // Don't fiddle with tooltips type, just hide it before move-to-rect
+    if (mPopupUseMoveToRect && gtk_widget_is_visible(mShell)) {
+      HideWaylandPopupWindow(/* aTemporaryHide */ true,
+                             /* aRemoveFromPopupList */ false);
+    }
+    LOG("  it's tooltip, quit");
+    return;
+  }
+
+  // See https://bugzilla.mozilla.org/show_bug.cgi?id=1785185#c8
+  // gtk_window_move() needs GDK_WINDOW_TYPE_HINT_UTILITY popup type.
+  // move-to-rect requires GDK_WINDOW_TYPE_HINT_POPUP_MENU popups type.
+  // We need to set it before map event when popup is hidden.
+  const GdkWindowTypeHint currentType =
+      gtk_window_get_type_hint(GTK_WINDOW(mShell));
+  const GdkWindowTypeHint requiredType = mPopupUseMoveToRect
+                                             ? GDK_WINDOW_TYPE_HINT_POPUP_MENU
+                                             : GDK_WINDOW_TYPE_HINT_UTILITY;
+
+  if (!mPopupUseMoveToRect && currentType == requiredType) {
+    LOG("  type matches and we're not forced to hide it, quit.");
+    return;
+  }
+
+  if (gtk_widget_is_visible(mShell)) {
+    HideWaylandPopupWindow(/* aTemporaryHide */ true,
+                           /* aRemoveFromPopupList */ false);
+  }
+
+  if (currentType != requiredType) {
+    LOG("  set type %s",
+        requiredType == GDK_WINDOW_TYPE_HINT_POPUP_MENU ? "MENU" : "UTILITY");
+    gtk_window_set_type_hint(GTK_WINDOW(mShell), requiredType);
+  }
+}
+
+// Plain popup move on Wayland - simply place popup on given location.
+// We can't just call gtk_window_move() as it's not effective on visible
+// popups.
+void nsWindow::WaylandPopupMovePlain(int aX, int aY) {
+  LOG("nsWindow::WaylandPopupMovePlain(%d, %d)", aX, aY);
+
+  // We can directly move only popups based on wl_subsurface type.
+  MOZ_DIAGNOSTIC_ASSERT(gtk_window_get_type_hint(GTK_WINDOW(mShell)) ==
+                            GDK_WINDOW_TYPE_HINT_UTILITY ||
+                        gtk_window_get_type_hint(GTK_WINDOW(mShell)) ==
+                            GDK_WINDOW_TYPE_HINT_TOOLTIP);
+
+  gtk_window_move(GTK_WINDOW(mShell), aX, aY);
+
+  // gtk_window_move() can trick us. When widget is hidden gtk_window_move()
+  // does not move the widget but sets new widget coordinates when widget
+  // is mapped again.
+  //
+  // If popup used move-to-rect before
+  // (GdkWindow has POSITION_METHOD_MOVE_TO_RECT set), popup will use
+  // move-to-rect again when it's mapped and we'll get bogus move-to-rect
+  // callback.
+  //
+  // gdk_window_move() sets position_method to POSITION_METHOD_MOVE_RESIZE
+  // so we'll use plain move when popup is shown.
+  if (!gtk_widget_get_mapped(mShell)) {
+    GdkWindow* window = gtk_widget_get_window(mShell);
+    if (window) {
+      gdk_window_move(window, aX, aY);
+    }
+  }
+}
+
+void nsWindow::WaylandPopupMoveImpl() {
+  // Available as of GTK 3.24+
+  static auto sGdkWindowMoveToRect = (void (*)(
+      GdkWindow*, const GdkRectangle*, GdkGravity, GdkGravity, GdkAnchorHints,
+      gint, gint))dlsym(RTLD_DEFAULT, "gdk_window_move_to_rect");
+
+  if (mPopupUseMoveToRect && !sGdkWindowMoveToRect) {
+    LOG("can't use move-to-rect due missing gdk_window_move_to_rect()");
+    mPopupUseMoveToRect = false;
+  }
+
+  GdkRectangle gtkAnchorRect;
+  GdkPoint offset;
+  if (mPopupUseMoveToRect) {
+    mPopupUseMoveToRect =
+        WaylandPopupCheckAndGetAnchor(&gtkAnchorRect, &offset);
+  }
+
+  LOG("nsWindow::WaylandPopupMove");
+  LOG("  original widget popup position [%d, %d]\n", mPopupPosition.x,
+      mPopupPosition.y);
+  LOG("  relative widget popup position [%d, %d]\n", mRelativePopupPosition.x,
+      mRelativePopupPosition.y);
+  LOG("  popup use move to rect %d", mPopupUseMoveToRect);
+
+  WaylandPopupPrepareForMove();
+
+  if (!mPopupUseMoveToRect) {
+    WaylandPopupMovePlain(mRelativePopupPosition.x, mRelativePopupPosition.y);
+    // Layout already should be aware of our bounds, since we didn't change it
+    // from the widget side for flipping or so.
+    return;
+  }
+
+  // Correct popup position now. It will be updated by gdk_window_move_to_rect()
+  // anyway but we need to set it now to avoid a race condition here.
+  WaylandPopupRemoveNegativePosition();
+
+  GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(mShell));
+  if (!g_signal_handler_find(gdkWindow, G_SIGNAL_MATCH_FUNC, 0, 0, nullptr,
+                             FuncToGpointer(NativeMoveResizeCallback), this)) {
+    g_signal_connect(gdkWindow, "moved-to-rect",
+                     G_CALLBACK(NativeMoveResizeCallback), this);
+  }
+  mWaitingForMoveToRectCallback = true;
+
+#ifdef MOZ_LOGGING
+  if (LOG_ENABLED()) {
+    LOG("  Call move-to-rect");
+    LOG("  Anchor rect [%d, %d] -> [%d x %d]", gtkAnchorRect.x, gtkAnchorRect.y,
+        gtkAnchorRect.width, gtkAnchorRect.height);
+    LOG("  Offset [%d, %d]", offset.x, offset.y);
+    LOG("  AnchorType");
+    LogPopupGravity(mPopupMoveToRectParams.mAnchorRectType);
+    LOG("  PopupAnchorType");
+    LogPopupGravity(mPopupMoveToRectParams.mPopupAnchorType);
+    LogPopupAnchorHints(mPopupMoveToRectParams.mHints);
+  }
+#endif
+
+  sGdkWindowMoveToRect(gdkWindow, &gtkAnchorRect,
+                       mPopupMoveToRectParams.mAnchorRectType,
+                       mPopupMoveToRectParams.mPopupAnchorType,
+                       mPopupMoveToRectParams.mHints, offset.x, offset.y);
+}
+
+void nsWindow::SetZIndex(int32_t aZIndex) {
+  nsIWidget* oldPrev = GetPrevSibling();
+
+  nsBaseWidget::SetZIndex(aZIndex);
+
+  if (GetPrevSibling() == oldPrev) {
+    return;
+  }
+
+  NS_ASSERTION(!mContainer, "Expected Mozilla child widget");
+
+  // We skip the nsWindows that don't have mGdkWindows.
+  // These are probably in the process of being destroyed.
+  if (!mGdkWindow) {
+    return;
+  }
+
+  if (!GetNextSibling()) {
+    // We're to be on top.
+    if (mGdkWindow) {
+      gdk_window_raise(mGdkWindow);
+    }
+  } else {
+    // All the siblings before us need to be below our widget.
+    for (nsWindow* w = this; w;
+         w = static_cast<nsWindow*>(w->GetPrevSibling())) {
+      if (w->mGdkWindow) {
+        gdk_window_lower(w->mGdkWindow);
+      }
+    }
+  }
+}
+
+void nsWindow::SetSizeMode(nsSizeMode aMode) {
+  LOG("nsWindow::SetSizeMode %d\n", aMode);
+
+  // Return if there's no shell or our current state is the same as the mode we
+  // were just set to.
+  if (!mShell) {
+    LOG("    no shell");
+    return;
+  }
+
+  if (mSizeMode == aMode && mLastSizeModeRequest == aMode) {
+    LOG("    already set");
+    return;
+  }
+
+  // It is tempting to try to optimize calls below based only on current
+  // mSizeMode, but that wouldn't work if there's a size-request in flight
+  // (specially before show). See bug 1789823.
+  const auto SizeModeMightBe = [&](nsSizeMode aModeToTest) {
+    if (mSizeMode != mLastSizeModeRequest) {
+      // Arbitrary size mode requests might be ongoing.
+      return true;
+    }
+    return mSizeMode == aModeToTest;
+  };
+
+  if (aMode != nsSizeMode_Fullscreen && aMode != nsSizeMode_Minimized) {
+    // Fullscreen and minimized are compatible.
+    if (SizeModeMightBe(nsSizeMode_Fullscreen)) {
+      MakeFullScreen(false);
+    }
+  }
+
+  switch (aMode) {
+    case nsSizeMode_Maximized:
+      LOG("    set maximized");
+      gtk_window_maximize(GTK_WINDOW(mShell));
+      break;
+    case nsSizeMode_Minimized:
+      LOG("    set minimized");
+      gtk_window_iconify(GTK_WINDOW(mShell));
+      break;
+    case nsSizeMode_Fullscreen:
+      LOG("    set fullscreen");
+      MakeFullScreen(true);
+      break;
+    default:
+      MOZ_FALLTHROUGH_ASSERT("Unknown size mode");
+    case nsSizeMode_Normal:
+      LOG("    set normal");
+      if (SizeModeMightBe(nsSizeMode_Maximized)) {
+        gtk_window_unmaximize(GTK_WINDOW(mShell));
+      }
+      if (SizeModeMightBe(nsSizeMode_Minimized)) {
+        gtk_window_deiconify(GTK_WINDOW(mShell));
+        // We need this for actual deiconification on mutter.
+        gtk_window_present(GTK_WINDOW(mShell));
+      }
+      break;
+  }
+  mLastSizeModeRequest = aMode;
+}
+
+#define kDesktopMutterSchema "org.gnome.mutter"_ns
+#define kDesktopDynamicWorkspacesKey "dynamic-workspaces"_ns
+
+static bool WorkspaceManagementDisabled(GdkScreen* screen) {
+  if (Preferences::GetBool("widget.disable-workspace-management", false)) {
+    return true;
+  }
+  if (Preferences::HasUserValue("widget.workspace-management")) {
+    return Preferences::GetBool("widget.workspace-management");
+  }
+
+  if (IsGnomeDesktopEnvironment()) {
+    // Gnome uses dynamic workspaces by default so disable workspace management
+    // in that case.
+    bool usesDynamicWorkspaces = true;
+    nsCOMPtr<nsIGSettingsService> gsettings =
+        do_GetService(NS_GSETTINGSSERVICE_CONTRACTID);
+    if (gsettings) {
+      nsCOMPtr<nsIGSettingsCollection> mutterSettings;
+      gsettings->GetCollectionForSchema(kDesktopMutterSchema,
+                                        getter_AddRefs(mutterSettings));
+      if (mutterSettings) {
+        mutterSettings->GetBoolean(kDesktopDynamicWorkspacesKey,
+                                   &usesDynamicWorkspaces);
+      }
+    }
+    return usesDynamicWorkspaces;
+  }
+
+  const auto& desktop = GetDesktopEnvironmentIdentifier();
+  return desktop.EqualsLiteral("bspwm") || desktop.EqualsLiteral("i3");
+}
+
+void nsWindow::GetWorkspaceID(nsAString& workspaceID) {
+  workspaceID.Truncate();
+
+  if (!GdkIsX11Display() || !mShell) {
+    return;
+  }
+
+#ifdef MOZ_X11
+  LOG("nsWindow::GetWorkspaceID()\n");
+
+  // Get the gdk window for this widget.
+  GdkWindow* gdk_window = gtk_widget_get_window(mShell);
+  if (!gdk_window) {
+    LOG("  missing Gdk window, quit.");
+    return;
+  }
+
+  if (WorkspaceManagementDisabled(gdk_window_get_screen(gdk_window))) {
+    LOG("  WorkspaceManagementDisabled, quit.");
+    return;
+  }
+
+  GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
+  GdkAtom type_returned;
+  int format_returned;
+  int length_returned;
+  long* wm_desktop;
+
+  if (!gdk_property_get(gdk_window, gdk_atom_intern("_NET_WM_DESKTOP", FALSE),
+                        cardinal_atom,
+                        0,          // offset
+                        INT32_MAX,  // length
+                        FALSE,      // delete
+                        &type_returned, &format_returned, &length_returned,
+                        (guchar**)&wm_desktop)) {
+    LOG("  gdk_property_get() failed, quit.");
+    return;
+  }
+
+  LOG("  got workspace ID %d", (int32_t)wm_desktop[0]);
+  workspaceID.AppendInt((int32_t)wm_desktop[0]);
+  g_free(wm_desktop);
+#endif
+}
+
+void nsWindow::MoveToWorkspace(const nsAString& workspaceIDStr) {
+  nsresult rv = NS_OK;
+  int32_t workspaceID = workspaceIDStr.ToInteger(&rv);
+
+  LOG("nsWindow::MoveToWorkspace() ID %d", workspaceID);
+  if (NS_FAILED(rv) || !workspaceID || !GdkIsX11Display() || !mShell) {
+    LOG("  MoveToWorkspace disabled, quit");
+    return;
+  }
+
+#ifdef MOZ_X11
+  // Get the gdk window for this widget.
+  GdkWindow* gdk_window = gtk_widget_get_window(mShell);
+  if (!gdk_window) {
+    LOG("  failed to get GdkWindow, quit.");
+    return;
+  }
+
+  // This code is inspired by some found in the 'gxtuner' project.
+  // https://github.com/brummer10/gxtuner/blob/792d453da0f3a599408008f0f1107823939d730d/deskpager.cpp#L50
+  XEvent xevent;
+  Display* xdisplay = gdk_x11_get_default_xdisplay();
+  GdkScreen* screen = gdk_window_get_screen(gdk_window);
+  Window root_win = GDK_WINDOW_XID(gdk_screen_get_root_window(screen));
+  GdkDisplay* display = gdk_window_get_display(gdk_window);
+  Atom type = gdk_x11_get_xatom_by_name_for_display(display, "_NET_WM_DESKTOP");
+
+  xevent.type = ClientMessage;
+  xevent.xclient.type = ClientMessage;
+  xevent.xclient.serial = 0;
+  xevent.xclient.send_event = TRUE;
+  xevent.xclient.display = xdisplay;
+  xevent.xclient.window = GDK_WINDOW_XID(gdk_window);
+  xevent.xclient.message_type = type;
+  xevent.xclient.format = 32;
+  xevent.xclient.data.l[0] = workspaceID;
+  xevent.xclient.data.l[1] = X11CurrentTime;
+  xevent.xclient.data.l[2] = 0;
+  xevent.xclient.data.l[3] = 0;
+  xevent.xclient.data.l[4] = 0;
+
+  XSendEvent(xdisplay, root_win, FALSE,
+             SubstructureNotifyMask | SubstructureRedirectMask, &xevent);
+
+  XFlush(xdisplay);
+  LOG("  moved to workspace");
+#endif
+}
+
+void nsWindow::SetUserTimeAndStartupTokenForActivatedWindow() {
+  nsGTKToolkit* toolkit = nsGTKToolkit::GetToolkit();
+  if (!toolkit || MOZ_UNLIKELY(mWindowType == eWindowType_invisible)) {
+    return;
+  }
+
+  mWindowActivationTokenFromEnv = toolkit->GetStartupToken();
+  if (!mWindowActivationTokenFromEnv.IsEmpty()) {
+    if (!GdkIsWaylandDisplay()) {
+      gtk_window_set_startup_id(GTK_WINDOW(mShell),
+                                mWindowActivationTokenFromEnv.get());
+      // In the case of X11, the above call is all we need. For wayland we need
+      // to keep the token around until we take it in
+      // TransferFocusToWaylandWindow.
+      mWindowActivationTokenFromEnv.Truncate();
+    }
+  } else if (uint32_t timestamp = toolkit->GetFocusTimestamp()) {
+    // We don't have the data we need. Fall back to an
+    // approximation ... using the timestamp of the remote command
+    // being received as a guess for the timestamp of the user event
+    // that triggered it.
+    gdk_window_focus(gtk_widget_get_window(mShell), timestamp);
+  }
+
+  // If we used the startup ID, that already contains the focus timestamp;
+  // we don't want to reuse the timestamp next time we raise the window
+  toolkit->SetFocusTimestamp(0);
+  toolkit->SetStartupToken(""_ns);
+}
+
+/* static */
+guint32 nsWindow::GetLastUserInputTime() {
+  // gdk_x11_display_get_user_time/gtk_get_current_event_time tracks
+  // button and key presses, DESKTOP_STARTUP_ID used to start the app,
+  // drop events from external drags,
+  // WM_DELETE_WINDOW delete events, but not usually mouse motion nor
+  // button and key releases.  Therefore use the most recent of
+  // gdk_x11_display_get_user_time and the last time that we have seen.
+#ifdef MOZ_X11
+  GdkDisplay* gdkDisplay = gdk_display_get_default();
+  guint32 timestamp = GdkIsX11Display(gdkDisplay)
+                          ? gdk_x11_display_get_user_time(gdkDisplay)
+                          : gtk_get_current_event_time();
+#else
+  guint32 timestamp = gtk_get_current_event_time();
+#endif
+
+  if (sLastUserInputTime != GDK_CURRENT_TIME &&
+      TimestampIsNewerThan(sLastUserInputTime, timestamp)) {
+    return sLastUserInputTime;
+  }
+
+  return timestamp;
+}
+
+#ifdef MOZ_WAYLAND
+void nsWindow::FocusWaylandWindow(const char* aTokenID) {
+  MOZ_DIAGNOSTIC_ASSERT(aTokenID);
+
+  LOG("nsWindow::FocusWaylandWindow(%s)", aTokenID);
+  if (IsDestroyed()) {
+    LOG("  already destroyed, quit.");
+    return;
+  }
+  wl_surface* surface =
+      mGdkWindow ? gdk_wayland_window_get_wl_surface(mGdkWindow) : nullptr;
+  if (!surface) {
+    LOG("  mGdkWindow is not visible, quit.");
+    return;
+  }
+
+  LOG("  requesting xdg-activation, surface ID %d",
+      wl_proxy_get_id((struct wl_proxy*)surface));
+  xdg_activation_v1* xdg_activation = WaylandDisplayGet()->GetXdgActivation();
+  if (!xdg_activation) {
+    return;
+  }
+  xdg_activation_v1_activate(xdg_activation, aTokenID, surface);
+}
+
+// Transfer focus from gFocusWindow to aWindow and use xdg_activation
+// protocol for it.
+void nsWindow::TransferFocusToWaylandWindow(nsWindow* aWindow) {
+  LOGW("nsWindow::TransferFocusToWaylandWindow(%p) gFocusWindow %p", aWindow,
+       gFocusWindow);
+  auto promise = mozilla::widget::RequestWaylandFocusPromise();
+  if (NS_WARN_IF(!promise)) {
+    LOGW("  quit, failed to create TransferFocusToWaylandWindow [%p]", aWindow);
+    return;
+  }
+  promise->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      /* resolve */
+      [window = RefPtr{aWindow}](nsCString token) {
+        window->FocusWaylandWindow(token.get());
+      },
+      /* reject */
+      [window = RefPtr{aWindow}](bool state) {
+        LOGW("TransferFocusToWaylandWindow [%p] failed", window.get());
+      });
+}
+#endif
+
+// Request activation of this window or give focus to this widget.
+// aRaise means whether we should request activation of this widget's
+// toplevel window.
+//
+// nsWindow::SetFocus(Raise::Yes) - Raise and give focus to toplevel window.
+// nsWindow::SetFocus(Raise::No) - Give focus to this window.
+void nsWindow::SetFocus(Raise aRaise, mozilla::dom::CallerType aCallerType) {
+  LOG("nsWindow::SetFocus Raise %d\n", aRaise == Raise::Yes);
+
+  // Raise the window if someone passed in true and the prefs are
+  // set properly.
+  GtkWidget* toplevelWidget = gtk_widget_get_toplevel(GTK_WIDGET(mContainer));
+
+  LOG("  gFocusWindow [%p]\n", gFocusWindow);
+  LOG("  mContainer [%p]\n", GTK_WIDGET(mContainer));
+  LOG("  Toplevel widget [%p]\n", toplevelWidget);
+
+  // Make sure that our owning widget has focus.  If it doesn't try to
+  // grab it.  Note that we don't set our focus flag in this case.
+  if (StaticPrefs::mozilla_widget_raise_on_setfocus_AtStartup() &&
+      aRaise == Raise::Yes && toplevelWidget &&
+      !gtk_widget_has_focus(toplevelWidget)) {
+    if (gtk_widget_get_visible(mShell)) {
+      LOG("  toplevel is not focused");
+      gdk_window_show_unraised(gtk_widget_get_window(mShell));
+      // Unset the urgency hint if possible.
+      SetUrgencyHint(mShell, false);
+    }
+  }
+
+  RefPtr<nsWindow> toplevelWindow = get_window_for_gtk_widget(toplevelWidget);
+  if (!toplevelWindow) {
+    LOG("  missing toplevel nsWindow, quit\n");
+    return;
+  }
+
+  if (aRaise == Raise::Yes) {
+    // means request toplevel activation.
+
+    // This is asynchronous. If and when the window manager accepts the request,
+    // then the focus widget will get a focus-in-event signal.
+    if (StaticPrefs::mozilla_widget_raise_on_setfocus_AtStartup() &&
+        toplevelWindow->mIsShown && toplevelWindow->mShell &&
+        !gtk_window_is_active(GTK_WINDOW(toplevelWindow->mShell))) {
+      LOG("  toplevel is visible but not active, requesting activation [%p]",
+          toplevelWindow.get());
+
+      // Take the time here explicitly for the call below.
+      const uint32_t timestamp = [&] {
+        if (nsGTKToolkit* toolkit = nsGTKToolkit::GetToolkit()) {
+          if (uint32_t t = toolkit->GetFocusTimestamp()) {
+            toolkit->SetFocusTimestamp(0);
+            return t;
+          }
+        }
+        return GetLastUserInputTime();
+      }();
+
+      toplevelWindow->SetUserTimeAndStartupTokenForActivatedWindow();
+      gtk_window_present_with_time(GTK_WINDOW(toplevelWindow->mShell),
+                                   timestamp);
+
+#ifdef MOZ_WAYLAND
+      if (GdkIsWaylandDisplay()) {
+        auto existingToken =
+            std::move(toplevelWindow->mWindowActivationTokenFromEnv);
+        if (!existingToken.IsEmpty()) {
+          LOG("  has existing activation token.");
+          toplevelWindow->FocusWaylandWindow(existingToken.get());
+        } else {
+          LOG("  missing activation token, try to transfer from focused "
+              "window");
+          TransferFocusToWaylandWindow(toplevelWindow);
+        }
+      }
+#endif
+    }
+    return;
+  }
+
+  // aRaise == No means that keyboard events should be dispatched from this
+  // widget.
+
+  // Ensure GTK_WIDGET(mContainer) is the focused GtkWidget within its toplevel
+  // window.
+  //
+  // For eWindowType_popup, this GtkWidget may not actually be the one that
+  // receives the key events as it may be the parent window that is active.
+  if (!gtk_widget_is_focus(GTK_WIDGET(mContainer))) {
+    // This is synchronous.  It takes focus from a plugin or from a widget
+    // in an embedder.  The focus manager already knows that this window
+    // is active so gBlockActivateEvent avoids another (unnecessary)
+    // activate notification.
+    gBlockActivateEvent = true;
+    gtk_widget_grab_focus(GTK_WIDGET(mContainer));
+    gBlockActivateEvent = false;
+  }
+
+  // If this is the widget that already has focus, return.
+  if (gFocusWindow == this) {
+    LOG("  already have focus");
+    return;
+  }
+
+  // Set this window to be the focused child window
+  gFocusWindow = this;
+
+  if (mIMContext) {
+    mIMContext->OnFocusWindow(this);
+  }
+
+  LOG("  widget now has focus in SetFocus()");
+}
+
+LayoutDeviceIntRect nsWindow::GetScreenBounds() {
+  const LayoutDeviceIntPoint origin = [&] {
+    // XXX Can't we use mGdkWindow here?
+    //
+    // Use the point including window decorations. Don't do this for popups,
+    // because we get wrong coordinates for gtk for override-redirect windows in
+    // HiDPI screens, and those don't have window decorations anyways.
+    //
+    // See https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/4820
+    if (mContainer && mWindowType != eWindowType_popup) {
+      gint x, y;
+      gdk_window_get_root_origin(gtk_widget_get_window(GTK_WIDGET(mContainer)),
+                                 &x, &y);
+      return GdkPointToDevicePixels({x, y});
+    }
+    return WidgetToScreenOffset();
+  }();
+
+  // mBounds.Size() is the window bounds, not the window-manager frame
+  // bounds (bug 581863).  gdk_window_get_frame_extents would give the
+  // frame bounds, but mBounds.Size() is returned here for consistency
+  // with Resize.
+  const LayoutDeviceIntRect rect(origin, mBounds.Size());
+#if MOZ_LOGGING
+  if (MOZ_LOG_TEST(IsPopup() ? gWidgetPopupLog : gWidgetLog,
+                   LogLevel::Verbose)) {
+    gint scale = GdkCeiledScaleFactor();
+    if (mLastLoggedScale != scale || !(mLastLoggedBoundSize == rect)) {
+      mLastLoggedScale = scale;
+      mLastLoggedBoundSize = rect;
+      LOG("GetScreenBounds %d,%d -> %d x %d, unscaled %d,%d -> %d x %d\n",
+          rect.x, rect.y, rect.width, rect.height, rect.x / scale,
+          rect.y / scale, rect.width / scale, rect.height / scale);
+    }
+  }
+#endif
+  return rect;
+}
+
+LayoutDeviceIntSize nsWindow::GetClientSize() {
+  return LayoutDeviceIntSize(mBounds.width, mBounds.height);
+}
+
+LayoutDeviceIntRect nsWindow::GetClientBounds() {
+  // GetBounds returns a rect whose top left represents the top left of the
+  // outer bounds, but whose width/height represent the size of the inner
+  // bounds (which is messed up).
+  LayoutDeviceIntRect rect = GetBounds();
+  rect.MoveBy(GetClientOffset());
+  return rect;
+}
+
+void nsWindow::RecomputeClientOffset(bool aNotify) {
+  if (mWindowType != eWindowType_dialog &&
+      mWindowType != eWindowType_toplevel) {
+    return;
+  }
+
+  auto oldOffset = mClientOffset;
+
+  mClientOffset = WidgetToScreenOffset() - mBounds.TopLeft();
+
+  if (aNotify && mClientOffset != oldOffset) {
+    // Send a WindowMoved notification. This ensures that BrowserParent picks up
+    // the new client offset and sends it to the child process if appropriate.
+    NotifyWindowMoved(mBounds.x, mBounds.y);
+  }
+}
+
+gboolean nsWindow::OnPropertyNotifyEvent(GtkWidget* aWidget,
+                                         GdkEventProperty* aEvent) {
+  if (aEvent->atom == gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE)) {
+    RecomputeClientOffset(/* aNotify = */ true);
+    return FALSE;
+  }
+  if (!mGdkWindow) {
+    return FALSE;
+  }
+#ifdef MOZ_X11
+  if (GetCurrentTimeGetter()->PropertyNotifyHandler(aWidget, aEvent)) {
+    return TRUE;
+  }
+#endif
+  return FALSE;
+}
+
+static GdkCursor* GetCursorForImage(const nsIWidget::Cursor& aCursor,
+                                    int32_t aWidgetScaleFactor) {
+  if (!aCursor.IsCustom()) {
+    return nullptr;
+  }
+  nsIntSize size = nsIWidget::CustomCursorSize(aCursor);
+
+  // NOTE: GTK only allows integer scale factors, so we ceil to the larger scale
+  // factor and then tell gtk to scale it down. We ensure to scale at least to
+  // the GDK scale factor, so that cursors aren't downsized in HiDPI on wayland,
+  // see bug 1707533.
+  int32_t gtkScale = std::max(
+      aWidgetScaleFactor, int32_t(std::ceil(std::max(aCursor.mResolution.mX,
+                                                     aCursor.mResolution.mY))));
+
+  // Reject cursors greater than 128 pixels in some direction, to prevent
+  // spoofing.
+  // XXX ideally we should rescale. Also, we could modify the API to
+  // allow trusted content to set larger cursors.
+  //
+  // TODO(emilio, bug 1445844): Unify the solution for this with other
+  // platforms.
+  if (size.width > 128 || size.height > 128) {
+    return nullptr;
+  }
+
+  nsIntSize rasterSize = size * gtkScale;
+  RefPtr<GdkPixbuf> pixbuf =
+      nsImageToPixbuf::ImageToPixbuf(aCursor.mContainer, Some(rasterSize));
+  if (!pixbuf) {
+    return nullptr;
+  }
+
+  // Looks like all cursors need an alpha channel (tested on Gtk 2.4.4). This
+  // is of course not documented anywhere...
+  // So add one if there isn't one yet
+  if (!gdk_pixbuf_get_has_alpha(pixbuf)) {
+    RefPtr<GdkPixbuf> alphaBuf =
+        dont_AddRef(gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0));
+    pixbuf = std::move(alphaBuf);
+    if (!pixbuf) {
+      return nullptr;
+    }
+  }
+
+  cairo_surface_t* surface =
+      gdk_cairo_surface_create_from_pixbuf(pixbuf, gtkScale, nullptr);
+  if (!surface) {
+    return nullptr;
+  }
+
+  auto CleanupSurface =
+      MakeScopeExit([&]() { cairo_surface_destroy(surface); });
+
+  return gdk_cursor_new_from_surface(gdk_display_get_default(), surface,
+                                     aCursor.mHotspotX, aCursor.mHotspotY);
+}
+
+void nsWindow::SetCursor(const Cursor& aCursor) {
+  // if we're not the toplevel window pass up the cursor request to
+  // the toplevel window to handle it.
+  if (!mContainer && mGdkWindow) {
+    if (nsWindow* window = GetContainerWindow()) {
+      window->SetCursor(aCursor);
+    }
+    return;
+  }
+
+  // Only change cursor if it's actually been changed
+  if (!mUpdateCursor && mCursor == aCursor) {
+    return;
+  }
+
+  mUpdateCursor = false;
+  mCursor = aCursor;
+
+  // Try to set the cursor image first, and fall back to the numeric cursor.
+  bool fromImage = true;
+  GdkCursor* newCursor = GetCursorForImage(aCursor, GdkCeiledScaleFactor());
+  if (!newCursor) {
+    fromImage = false;
+    newCursor = get_gtk_cursor(aCursor.mDefaultCursor);
+  }
+
+  auto CleanupCursor = mozilla::MakeScopeExit([&]() {
+    // get_gtk_cursor returns a weak reference, which we shouldn't unref.
+    if (fromImage) {
+      g_object_unref(newCursor);
+    }
+  });
+
+  if (!newCursor || !mContainer) {
+    return;
+  }
+
+  gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(mContainer)),
+                        newCursor);
+}
+
+void nsWindow::Invalidate(const LayoutDeviceIntRect& aRect) {
+  if (!mGdkWindow) return;
+
+  GdkRectangle rect = DevicePixelsToGdkRectRoundOut(aRect);
+  gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
+
+  LOG("Invalidate (rect): %d %d %d %d\n", rect.x, rect.y, rect.width,
+      rect.height);
+}
+
+void* nsWindow::GetNativeData(uint32_t aDataType) {
+  switch (aDataType) {
+    case NS_NATIVE_WINDOW:
+    case NS_NATIVE_WIDGET: {
+      return mGdkWindow;
+    }
+
+    case NS_NATIVE_DISPLAY: {
+#ifdef MOZ_X11
+      GdkDisplay* gdkDisplay = gdk_display_get_default();
+      if (GdkIsX11Display(gdkDisplay)) {
+        return GDK_DISPLAY_XDISPLAY(gdkDisplay);
+      }
+#endif /* MOZ_X11 */
+      // Don't bother to return native display on Wayland as it's for
+      // X11 only NPAPI plugins.
+      return nullptr;
+    }
+    case NS_NATIVE_SHELLWIDGET:
+      return GetToplevelWidget();
+
+    case NS_NATIVE_WINDOW_WEBRTC_DEVICE_ID:
+#ifdef MOZ_X11
+      if (GdkIsX11Display()) {
+        return (void*)GDK_WINDOW_XID(gdk_window_get_toplevel(mGdkWindow));
+      }
+#endif
+      NS_WARNING(
+          "nsWindow::GetNativeData(): NS_NATIVE_WINDOW_WEBRTC_DEVICE_ID is not "
+          "handled on Wayland!");
+      return nullptr;
+    case NS_RAW_NATIVE_IME_CONTEXT: {
+      void* pseudoIMEContext = GetPseudoIMEContext();
+      if (pseudoIMEContext) {
+        return pseudoIMEContext;
+      }
+      // If IME context isn't available on this widget, we should set |this|
+      // instead of nullptr.
+      if (!mIMContext) {
+        return this;
+      }
+      return mIMContext.get();
+    }
+    case NS_NATIVE_OPENGL_CONTEXT:
+      return nullptr;
+    case NS_NATIVE_EGL_WINDOW: {
+      void* eglWindow = nullptr;
+#ifdef MOZ_X11
+      if (GdkIsX11Display()) {
+        eglWindow = mGdkWindow ? (void*)GDK_WINDOW_XID(mGdkWindow) : nullptr;
+      }
+#endif
+#ifdef MOZ_WAYLAND
+      if (GdkIsWaylandDisplay()) {
+        if (mCompositorWidgetDelegate &&
+            mCompositorWidgetDelegate->AsGtkCompositorWidget()) {
+          MOZ_DIAGNOSTIC_ASSERT(
+              !mCompositorWidgetDelegate->AsGtkCompositorWidget()->IsHidden(),
+              "We're getting OpenGL window for hidden window!");
+        }
+        eglWindow = moz_container_wayland_get_egl_window(
+            mContainer, FractionalScaleFactor());
+      }
+#endif
+      LOG("Get NS_NATIVE_EGL_WINDOW mGdkWindow %p returned eglWindow %p",
+          mGdkWindow, eglWindow);
+      return eglWindow;
+    }
+    default:
+      NS_WARNING("nsWindow::GetNativeData called with bad value");
+      return nullptr;
+  }
+}
+
+nsresult nsWindow::SetTitle(const nsAString& aTitle) {
+  if (!mShell) return NS_OK;
+
+    // convert the string into utf8 and set the title.
+#define UTF8_FOLLOWBYTE(ch) (((ch)&0xC0) == 0x80)
+  NS_ConvertUTF16toUTF8 titleUTF8(aTitle);
+  if (titleUTF8.Length() > NS_WINDOW_TITLE_MAX_LENGTH) {
+    // Truncate overlong titles (bug 167315). Make sure we chop after a
+    // complete sequence by making sure the next char isn't a follow-byte.
+    uint32_t len = NS_WINDOW_TITLE_MAX_LENGTH;
+    while (UTF8_FOLLOWBYTE(titleUTF8[len])) --len;
+    titleUTF8.Truncate(len);
+  }
+  gtk_window_set_title(GTK_WINDOW(mShell), (const char*)titleUTF8.get());
+
+  return NS_OK;
+}
+
+void nsWindow::SetIcon(const nsAString& aIconSpec) {
+  if (!mShell) return;
+
+  nsAutoCString iconName;
+
+  if (aIconSpec.EqualsLiteral("default")) {
+    nsAutoString brandName;
+    WidgetUtils::GetBrandShortName(brandName);
+    if (brandName.IsEmpty()) {
+      brandName.AssignLiteral(u"Mozilla");
+    }
+    AppendUTF16toUTF8(brandName, iconName);
+    ToLowerCase(iconName);
+  } else {
+    AppendUTF16toUTF8(aIconSpec, iconName);
+  }
+
+  nsCOMPtr<nsIFile> iconFile;
+  nsAutoCString path;
+
+  gint* iconSizes = gtk_icon_theme_get_icon_sizes(gtk_icon_theme_get_default(),
+                                                  iconName.get());
+  bool foundIcon = (iconSizes[0] != 0);
+  g_free(iconSizes);
+
+  if (!foundIcon) {
+    // Look for icons with the following suffixes appended to the base name
+    // The last two entries (for the old XPM format) will be ignored unless
+    // no icons are found using other suffixes. XPM icons are deprecated.
+
+    const char16_t extensions[9][8] = {u".png",    u"16.png", u"32.png",
+                                       u"48.png",  u"64.png", u"128.png",
+                                       u"256.png", u".xpm",   u"16.xpm"};
+
+    for (uint32_t i = 0; i < ArrayLength(extensions); i++) {
+      // Don't bother looking for XPM versions if we found a PNG.
+      if (i == ArrayLength(extensions) - 2 && foundIcon) break;
+
+      ResolveIconName(aIconSpec, nsDependentString(extensions[i]),
+                      getter_AddRefs(iconFile));
+      if (iconFile) {
+        iconFile->GetNativePath(path);
+        GdkPixbuf* icon = gdk_pixbuf_new_from_file(path.get(), nullptr);
+        if (icon) {
+          gtk_icon_theme_add_builtin_icon(iconName.get(),
+                                          gdk_pixbuf_get_height(icon), icon);
+          g_object_unref(icon);
+          foundIcon = true;
+        }
+      }
+    }
+  }
+
+  // leave the default icon intact if no matching icons were found
+  if (foundIcon) {
+    gtk_window_set_icon_name(GTK_WINDOW(mShell), iconName.get());
+  }
+}
+
+/* TODO(bug 1655924): gdk_window_get_origin is can block waiting for the X
+   server for a long time, we would like to use the implementation below
+   instead. However, removing the synchronous x server queries causes a race
+   condition to surface, causing issues such as bug 1652743 and bug 1653711.
+
+
+   This code can be used instead of gdk_window_get_origin() but it cuases
+   such issues:
+
+    *aX = 0;
+    *aY = 0;
+    if (!aWindow) {
+      return;
+    }
+
+    GdkWindow* current = aWindow;
+    while (GdkWindow* parent = gdk_window_get_parent(current)) {
+      if (parent == current) {
+        break;
+      }
+
+      int x = 0;
+      int y = 0;
+      gdk_window_get_position(current, &x, &y);
+      *aX += x;
+      *aY += y;
+
+      current = parent;
+    }
+*/
+LayoutDeviceIntPoint nsWindow::WidgetToScreenOffset() {
+  // Don't use gdk_window_get_origin() on wl_subsurface Wayland popups
+  // https://gitlab.gnome.org/GNOME/gtk/-/issues/5287
+  if (IsWaylandPopup() && !mPopupUseMoveToRect) {
+    return mBounds.TopLeft();
+  }
+  nsIntPoint origin(0, 0);
+  if (mGdkWindow) {
+    gdk_window_get_origin(mGdkWindow, &origin.x.value, &origin.y.value);
+  }
+  return GdkPointToDevicePixels({origin.x, origin.y});
+}
+
+void nsWindow::CaptureRollupEvents(bool aDoCapture) {
+  LOG("CaptureRollupEvents(%d)\n", aDoCapture);
+  if (mIsDestroyed) {
+    return;
+  }
+
+  static constexpr auto kCaptureEventsMask =
+      GdkEventMask(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+                   GDK_POINTER_MOTION_MASK | GDK_TOUCH_MASK);
+
+  static bool sSystemNeedsPointerGrab = [&] {
+    if (GdkIsWaylandDisplay()) {
+      return false;
+    }
+    // We only need to grab the pointer for X servers that move the focus with
+    // the pointer (like twm, sawfish...). Since we roll up popups on focus out,
+    // not grabbing the pointer triggers rollup when the mouse enters the popup
+    // and leaves the main window, see bug 1807482.
+    //
+    // FVWM is also affected but less severely: the pointer can enter the
+    // popup, but if it briefly moves out of the popup and over the main window
+    // then we see a focus change and roll up the popup.
+    //
+    // We don't do it for most common desktops, if only because it causes X11
+    // crashes like bug 1607713.
+    const auto& desktop = GetDesktopEnvironmentIdentifier();
+    return desktop.EqualsLiteral("twm") || desktop.EqualsLiteral("sawfish") ||
+           StringBeginsWith(desktop, "fvwm"_ns);
+  }();
+
+  const bool grabPointer = [] {
+    switch (StaticPrefs::widget_gtk_grab_pointer()) {
+      case 0:
+        return false;
+      case 1:
+        return true;
+      default:
+        return sSystemNeedsPointerGrab;
+    }
+  }();
+
+  if (!grabPointer) {
+    return;
+  }
+
+  mNeedsToRetryCapturingMouse = false;
+  if (aDoCapture) {
+    if (mIsDragPopup || DragInProgress()) {
+      // Don't add a grab if a drag is in progress, or if the widget is a drag
+      // feedback popup. (panels with type="drag").
+      return;
+    }
+
+    if (!mHasMappedToplevel) {
+      // On X, capturing an unmapped window is pointless (returns
+      // GDK_GRAB_NOT_VIEWABLE). Avoid the X server round-trip and just retry
+      // when we're mapped.
+      mNeedsToRetryCapturingMouse = true;
+      return;
+    }
+
+    GdkGrabStatus status = gdk_device_grab(
+        GdkGetPointer(), GetToplevelGdkWindow(), GDK_OWNERSHIP_NONE,
+        /* owner_events = */ true, kCaptureEventsMask,
+        /* cursor = */ nullptr, GetLastUserInputTime());
+    Unused << NS_WARN_IF(status != GDK_GRAB_SUCCESS);
+    LOG(" > pointer grab with status %d", int(status));
+    gtk_grab_add(GTK_WIDGET(mContainer));
+  } else {
+    // There may not have been a drag in process when aDoCapture was set,
+    // so make sure to remove any added grab.  This is a no-op if the grab
+    // was not added to this widget.
+    gtk_grab_remove(GTK_WIDGET(mContainer));
+    gdk_device_ungrab(GdkGetPointer(), GetLastUserInputTime());
+  }
+}
+
+nsresult nsWindow::GetAttention(int32_t aCycleCount) {
+  LOG("nsWindow::GetAttention");
+
+  GtkWidget* top_window = GetToplevelWidget();
+  GtkWidget* top_focused_window =
+      gFocusWindow ? gFocusWindow->GetToplevelWidget() : nullptr;
+
+  // Don't get attention if the window is focused anyway.
+  if (top_window && (gtk_widget_get_visible(top_window)) &&
+      top_window != top_focused_window) {
+    SetUrgencyHint(top_window, true);
+  }
+
+  return NS_OK;
+}
+
+bool nsWindow::HasPendingInputEvent() {
+  // This sucks, but gtk/gdk has no way to answer the question we want while
+  // excluding paint events, and there's no X API that will let us peek
+  // without blocking or removing.  To prevent event reordering, peek
+  // anything except expose events.  Reordering expose and others should be
+  // ok, hopefully.
+  bool haveEvent = false;
+#ifdef MOZ_X11
+  XEvent ev;
+  if (GdkIsX11Display()) {
+    Display* display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+    haveEvent = XCheckMaskEvent(
+        display,
+        KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
+            EnterWindowMask | LeaveWindowMask | PointerMotionMask |
+            PointerMotionHintMask | Button1MotionMask | Button2MotionMask |
+            Button3MotionMask | Button4MotionMask | Button5MotionMask |
+            ButtonMotionMask | KeymapStateMask | VisibilityChangeMask |
+            StructureNotifyMask | ResizeRedirectMask | SubstructureNotifyMask |
+            SubstructureRedirectMask | FocusChangeMask | PropertyChangeMask |
+            ColormapChangeMask | OwnerGrabButtonMask,
+        &ev);
+    if (haveEvent) {
+      XPutBackEvent(display, &ev);
+    }
+  }
+#endif
+  return haveEvent;
+}
+
+#ifdef cairo_copy_clip_rectangle_list
+#  error "Looks like we're including Mozilla's cairo instead of system cairo"
+#endif
+static bool ExtractExposeRegion(LayoutDeviceIntRegion& aRegion, cairo_t* cr) {
+  cairo_rectangle_list_t* rects = cairo_copy_clip_rectangle_list(cr);
+  if (rects->status != CAIRO_STATUS_SUCCESS) {
+    NS_WARNING("Failed to obtain cairo rectangle list.");
+    return false;
+  }
+
+  for (int i = 0; i < rects->num_rectangles; i++) {
+    const cairo_rectangle_t& r = rects->rectangles[i];
+    aRegion.Or(aRegion,
+               LayoutDeviceIntRect::Truncate((float)r.x, (float)r.y,
+                                             (float)r.width, (float)r.height));
+  }
+
+  cairo_rectangle_list_destroy(rects);
+  return true;
+}
+
+#ifdef MOZ_WAYLAND
+void nsWindow::CreateCompositorVsyncDispatcher() {
+  LOG_VSYNC("nsWindow::CreateCompositorVsyncDispatcher()");
+  if (!mWaylandVsyncSource) {
+    LOG_VSYNC(
+        "  mWaylandVsyncSource is missing, create "
+        "nsBaseWidget::CompositorVsyncDispatcher()");
+    nsBaseWidget::CreateCompositorVsyncDispatcher();
+    return;
+  }
+
+  if (XRE_IsParentProcess()) {
+    if (!mCompositorVsyncDispatcherLock) {
+      mCompositorVsyncDispatcherLock =
+          MakeUnique<Mutex>("mCompositorVsyncDispatcherLock");
+    }
+    MutexAutoLock lock(*mCompositorVsyncDispatcherLock);
+    if (!mCompositorVsyncDispatcher) {
+      LOG_VSYNC("  create CompositorVsyncDispatcher()");
+      mCompositorVsyncDispatcher =
+          new CompositorVsyncDispatcher(mWaylandVsyncDispatcher);
+    }
+  }
+}
+#endif
+
+gboolean nsWindow::OnExposeEvent(cairo_t* cr) {
+  // Send any pending resize events so that layout can update.
+  // May run event loop.
+  MaybeDispatchResized();
+
+  if (mIsDestroyed) {
+    return FALSE;
+  }
+
+  // Windows that are not visible will be painted after they become visible.
+  if (!mGdkWindow || !mHasMappedToplevel) {
+    return FALSE;
+  }
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay() && !moz_container_wayland_can_draw(mContainer)) {
+    return FALSE;
+  }
+#endif
+
+  nsIWidgetListener* listener = GetListener();
+  if (!listener) return FALSE;
+
+  LOG("nsWindow::OnExposeEvent GdkWindow [%p] XWindow [0x%lx]", mGdkWindow,
+      GetX11Window());
+
+  LayoutDeviceIntRegion exposeRegion;
+  if (!ExtractExposeRegion(exposeRegion, cr)) {
+    LOG("  no rects, quit");
+    return FALSE;
+  }
+
+  gint scale = GdkCeiledScaleFactor();
+  LayoutDeviceIntRegion region = exposeRegion;
+  region.ScaleRoundOut(scale, scale);
+
+  WindowRenderer* renderer = GetWindowRenderer();
+  WebRenderLayerManager* layerManager = renderer->AsWebRender();
+  KnowsCompositor* knowsCompositor = renderer->AsKnowsCompositor();
+
+  if (knowsCompositor && layerManager && mCompositorSession) {
+    if (!mConfiguredClearColor && !IsPopup()) {
+      layerManager->WrBridge()->SendSetDefaultClearColor(LookAndFeel::Color(
+          LookAndFeel::ColorID::Window, LookAndFeel::ColorSchemeForChrome(),
+          LookAndFeel::UseStandins::No));
+      mConfiguredClearColor = true;
+    }
+
+    // We need to paint to the screen even if nothing changed, since if we
+    // don't have a compositing window manager, our pixels could be stale.
+    layerManager->SetNeedsComposite(true);
+    layerManager->SendInvalidRegion(region.ToUnknownRegion());
+  }
+
+  RefPtr<nsWindow> strongThis(this);
+
+  // Dispatch WillPaintWindow notification to allow scripts etc. to run
+  // before we paint
+  {
+    listener->WillPaintWindow(this);
+
+    // If the window has been destroyed during the will paint notification,
+    // there is nothing left to do.
+    if (!mGdkWindow) return TRUE;
+
+    // Re-get the listener since the will paint notification might have
+    // killed it.
+    listener = GetListener();
+    if (!listener) return FALSE;
+  }
+
+  if (knowsCompositor && layerManager && layerManager->NeedsComposite()) {
+    layerManager->ScheduleComposite(wr::RenderReasons::WIDGET);
+    layerManager->SetNeedsComposite(false);
+  }
+
+  // Our bounds may have changed after calling WillPaintWindow.  Clip
+  // to the new bounds here.  The region is relative to this
+  // window.
+  region.And(region, LayoutDeviceIntRect(0, 0, mBounds.width, mBounds.height));
+
+  bool shaped = false;
+  if (eTransparencyTransparent == GetTransparencyMode()) {
+    auto* window = static_cast<nsWindow*>(GetTopLevelWidget());
+    if (mTransparencyBitmapForTitlebar) {
+      if (mSizeMode == nsSizeMode_Normal) {
+        window->UpdateTitlebarTransparencyBitmap();
+      } else {
+        window->ClearTransparencyBitmap();
+      }
+    } else {
+      if (mHasAlphaVisual) {
+        // Remove possible shape mask from when window manger was not
+        // previously compositing.
+        window->ClearTransparencyBitmap();
+      } else {
+        shaped = true;
+      }
+    }
+  }
+
+  if (region.IsEmpty()) {
+    return TRUE;
+  }
+
+  // If this widget uses OMTC...
+  if (renderer->GetBackendType() == LayersBackend::LAYERS_WR) {
+    listener->PaintWindow(this, region);
+
+    // Re-get the listener since the will paint notification might have
+    // killed it.
+    listener = GetListener();
+    if (!listener) return TRUE;
+
+    listener->DidPaintWindow();
+    return TRUE;
+  }
+
+  BufferMode layerBuffering = BufferMode::BUFFERED;
+  RefPtr<DrawTarget> dt = StartRemoteDrawingInRegion(region, &layerBuffering);
+  if (!dt || !dt->IsValid()) {
+    return FALSE;
+  }
+  RefPtr<gfxContext> ctx;
+  IntRect boundsRect = region.GetBounds().ToUnknownRect();
+  IntPoint offset(0, 0);
+  if (dt->GetSize() == boundsRect.Size()) {
+    offset = boundsRect.TopLeft();
+    dt->SetTransform(Matrix::Translation(-offset));
+  }
+
+#ifdef MOZ_X11
+  if (shaped) {
+    // Collapse update area to the bounding box. This is so we only have to
+    // call UpdateTranslucentWindowAlpha once. After we have dropped
+    // support for non-Thebes graphics, UpdateTranslucentWindowAlpha will be
+    // our private interface so we can rework things to avoid this.
+    dt->PushClipRect(Rect(boundsRect));
+
+    // The double buffering is done here to extract the shape mask.
+    // (The shape mask won't be necessary when a visual with an alpha
+    // channel is used on compositing window managers.)
+    layerBuffering = BufferMode::BUFFER_NONE;
+    RefPtr<DrawTarget> destDT =
+        dt->CreateSimilarDrawTarget(boundsRect.Size(), SurfaceFormat::B8G8R8A8);
+    if (!destDT || !destDT->IsValid()) {
+      return FALSE;
+    }
+    destDT->SetTransform(Matrix::Translation(-boundsRect.TopLeft()));
+    ctx = gfxContext::CreatePreservingTransformOrNull(destDT);
+  } else {
+    gfxUtils::ClipToRegion(dt, region.ToUnknownRegion());
+    ctx = gfxContext::CreatePreservingTransformOrNull(dt);
+  }
+  MOZ_ASSERT(ctx);  // checked both dt and destDT valid draw target above
+
+#  if 0
+    // NOTE: Paint flashing region would be wrong for cairo, since
+    // cairo inflates the update region, etc.  So don't paint flash
+    // for cairo.
+#    ifdef DEBUG
+    // XXX aEvent->region may refer to a newly-invalid area.  FIXME
+    if (0 && WANT_PAINT_FLASHING && gtk_widget_get_window(aEvent))
+        gdk_window_flash(mGdkWindow, 1, 100, aEvent->region);
+#    endif
+#  endif
+
+#endif  // MOZ_X11
+
+  bool painted = false;
+  {
+    if (renderer->GetBackendType() == LayersBackend::LAYERS_NONE) {
+      if (GetTransparencyMode() == eTransparencyTransparent &&
+          layerBuffering == BufferMode::BUFFER_NONE && mHasAlphaVisual) {
+        // If our draw target is unbuffered and we use an alpha channel,
+        // clear the image beforehand to ensure we don't get artifacts from a
+        // reused SHM image. See bug 1258086.
+        dt->ClearRect(Rect(boundsRect));
+      }
+      AutoLayerManagerSetup setupLayerManager(this, ctx, layerBuffering);
+      painted = listener->PaintWindow(this, region);
+
+      // Re-get the listener since the will paint notification might have
+      // killed it.
+      listener = GetListener();
+      if (!listener) return TRUE;
+    }
+  }
+
+#ifdef MOZ_X11
+  // PaintWindow can Destroy us (bug 378273), avoid doing any paint
+  // operations below if that happened - it will lead to XError and exit().
+  if (shaped) {
+    if (MOZ_LIKELY(!mIsDestroyed)) {
+      if (painted) {
+        RefPtr<SourceSurface> surf = ctx->GetDrawTarget()->Snapshot();
+
+        UpdateAlpha(surf, boundsRect);
+
+        dt->DrawSurface(surf, Rect(boundsRect),
+                        Rect(0, 0, boundsRect.width, boundsRect.height),
+                        DrawSurfaceOptions(SamplingFilter::POINT),
+                        DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+      }
+    }
+  }
+
+  ctx = nullptr;
+  dt->PopClip();
+
+#endif  // MOZ_X11
+
+  EndRemoteDrawingInRegion(dt, region);
+
+  listener->DidPaintWindow();
+
+  // Synchronously flush any new dirty areas
+  cairo_region_t* dirtyArea = gdk_window_get_update_area(mGdkWindow);
+
+  if (dirtyArea) {
+    gdk_window_invalidate_region(mGdkWindow, dirtyArea, false);
+    cairo_region_destroy(dirtyArea);
+    gdk_window_process_updates(mGdkWindow, false);
+  }
+
+  // check the return value!
+  return TRUE;
+}
+
+void nsWindow::UpdateAlpha(SourceSurface* aSourceSurface,
+                           nsIntRect aBoundsRect) {
+  // We need to create our own buffer to force the stride to match the
+  // expected stride.
+  int32_t stride =
+      GetAlignedStride<4>(aBoundsRect.width, BytesPerPixel(SurfaceFormat::A8));
+  if (stride == 0) {
+    return;
+  }
+  int32_t bufferSize = stride * aBoundsRect.height;
+  auto imageBuffer = MakeUniqueFallible<uint8_t[]>(bufferSize);
+  {
+    RefPtr<DrawTarget> drawTarget = gfxPlatform::CreateDrawTargetForData(
+        imageBuffer.get(), aBoundsRect.Size(), stride, SurfaceFormat::A8);
+
+    if (drawTarget) {
+      drawTarget->DrawSurface(aSourceSurface,
+                              Rect(0, 0, aBoundsRect.width, aBoundsRect.height),
+                              Rect(0, 0, aSourceSurface->GetSize().width,
+                                   aSourceSurface->GetSize().height),
+                              DrawSurfaceOptions(SamplingFilter::POINT),
+                              DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+    }
+  }
+  UpdateTranslucentWindowAlphaInternal(aBoundsRect, imageBuffer.get(), stride);
+}
+
+gboolean nsWindow::OnConfigureEvent(GtkWidget* aWidget,
+                                    GdkEventConfigure* aEvent) {
+  // These events are only received on toplevel windows.
+  //
+  // GDK ensures that the coordinates are the client window top-left wrt the
+  // root window.
+  //
+  //   GDK calculates the cordinates for real ConfigureNotify events on
+  //   managed windows (that would normally be relative to the parent
+  //   window).
+  //
+  //   Synthetic ConfigureNotify events are from the window manager and
+  //   already relative to the root window.  GDK creates all X windows with
+  //   border_width = 0, so synthetic events also indicate the top-left of
+  //   the client window.
+  //
+  //   Override-redirect windows are children of the root window so parent
+  //   coordinates are root coordinates.
+
+  LOG("configure event %d,%d -> %d x %d scale %d\n", aEvent->x, aEvent->y,
+      aEvent->width, aEvent->height,
+      mGdkWindow ? gdk_window_get_scale_factor(mGdkWindow) : -1);
+
+  if (mPendingConfigures > 0) {
+    mPendingConfigures--;
+  }
+
+  // Don't fire configure event for scale changes, we handle that
+  // OnScaleChanged event. Skip that for toplevel windows only.
+  if (mGdkWindow && (mWindowType == eWindowType_toplevel ||
+                     mWindowType == eWindowType_dialog)) {
+    if (mWindowScaleFactor != gdk_window_get_scale_factor(mGdkWindow)) {
+      LOG("  scale factor changed to %d,return early",
+          gdk_window_get_scale_factor(mGdkWindow));
+      return FALSE;
+    }
+  }
+
+  LayoutDeviceIntRect screenBounds = GetScreenBounds();
+
+  if (mWindowType == eWindowType_toplevel ||
+      mWindowType == eWindowType_dialog) {
+    // This check avoids unwanted rollup on spurious configure events from
+    // Cygwin/X (bug 672103).
+    if (mBounds.x != screenBounds.x || mBounds.y != screenBounds.y) {
+      CheckForRollup(0, 0, false, true);
+    }
+  }
+
+  NS_ASSERTION(GTK_IS_WINDOW(aWidget),
+               "Configure event on widget that is not a GtkWindow");
+  if (mGdkWindow &&
+      gtk_window_get_window_type(GTK_WINDOW(aWidget)) == GTK_WINDOW_POPUP) {
+    // Override-redirect window
+    //
+    // These windows should not be moved by the window manager, and so any
+    // change in position is a result of our direction.  mBounds has
+    // already been set in std::move() or Resize(), and that is more
+    // up-to-date than the position in the ConfigureNotify event if the
+    // event is from an earlier window move.
+    //
+    // Skipping the WindowMoved call saves context menus from an infinite
+    // loop when nsXULPopupManager::PopupMoved moves the window to the new
+    // position and nsMenuPopupFrame::SetPopupPosition adds
+    // offsetForContextMenu on each iteration.
+
+    // Our back buffer might have been invalidated while we drew the last
+    // frame, and its contents might be incorrect. See bug 1280653 comment 7
+    // and comment 10. Specifically we must ensure we recomposite the frame
+    // as soon as possible to avoid the corrupted frame being displayed.
+    GetWindowRenderer()->FlushRendering(wr::RenderReasons::WIDGET);
+    return FALSE;
+  }
+
+  mBounds.MoveTo(screenBounds.TopLeft());
+  RecomputeClientOffset(/* aNotify = */ false);
+
+  // XXX mozilla will invalidate the entire window after this move
+  // complete.  wtf?
+  NotifyWindowMoved(mBounds.x, mBounds.y);
+
+  return FALSE;
+}
+
+void nsWindow::OnMap() {
+  LOG("nsWindow::OnMap");
+  // Gtk mapped widget to screen. Configure underlying GdkWindow properly
+  // as our rendering target.
+  // This call means we have X11 (or Wayland) window we can render to by GL
+  // so we need to notify compositor about it.
+  mIsMapped = true;
+  ConfigureGdkWindow();
+}
+
+void nsWindow::OnUnmap() {
+  LOG("nsWindow::OnUnmap");
+
+  // Mark window as unmapped. It can be still used for rendering on X11
+  // untill OnUnrealize is called.
+  mIsMapped = false;
+
+  if (mSourceDragContext) {
+    static auto sGtkDragCancel =
+        (void (*)(GdkDragContext*))dlsym(RTLD_DEFAULT, "gtk_drag_cancel");
+    if (sGtkDragCancel) {
+      sGtkDragCancel(mSourceDragContext);
+      mSourceDragContext = nullptr;
+    }
+  }
+
+#ifdef MOZ_WAYLAND
+  // wl_surface owned by mContainer is going to be deleted.
+  // Make sure we don't paint to it on Wayland.
+  if (GdkIsWaylandDisplay()) {
+    if (mCompositorWidgetDelegate) {
+      mCompositorWidgetDelegate->DisableRendering();
+    }
+    if (moz_container_wayland_has_egl_window(mContainer)) {
+      // Widget is backed by OpenGL EGLSurface created over wl_surface
+      // owned by mContainer.
+      // RenderCompositorEGL::Resume() deletes recent EGLSurface based on
+      // wl_surface owned by mContainer and creates a new fallback EGLSurface.
+      // Then we can delete wl_surface in moz_container_wayland_unmap().
+      // We don't want to pause compositor as it may lead to whole
+      // browser freeze (Bug 1777664).
+      if (CompositorBridgeChild* remoteRenderer = GetRemoteRenderer()) {
+        remoteRenderer->SendResume();
+      }
+    }
+    if (GdkIsWaylandDisplay()) {
+      moz_container_wayland_unmap(GTK_WIDGET(mContainer));
+    }
+  }
+#endif
+  moz_container_unmap(GTK_WIDGET(mContainer));
+}
+
+void nsWindow::OnUnrealize() {
+  // The GdkWindows are about to be destroyed (but not deleted), so remove
+  // their references back to their container widget while the GdkWindow
+  // hierarchy is still available.
+  // This call means we *don't* have X11 (or Wayland) window we can render to.
+  LOG("nsWindow::OnUnrealize GdkWindow %p", mGdkWindow);
+  ReleaseGdkWindow();
+}
+
+void nsWindow::OnSizeAllocate(GtkAllocation* aAllocation) {
+  LOG("nsWindow::OnSizeAllocate %d,%d -> %d x %d\n", aAllocation->x,
+      aAllocation->y, aAllocation->width, aAllocation->height);
+
+  // Client offset are updated by _NET_FRAME_EXTENTS on X11 when system titlebar
+  // is enabled. In either cases (Wayland or system titlebar is off on X11)
+  // we don't get _NET_FRAME_EXTENTS X11 property notification so we derive
+  // it from mContainer position.
+  RecomputeClientOffset(/* aNotify = */ true);
+
+  mHasReceivedSizeAllocate = true;
+
+  LayoutDeviceIntSize size = GdkRectToDevicePixels(*aAllocation).Size();
+
+  // Sometimes the window manager gives us garbage sizes (way past the maximum
+  // texture size) causing crashes if we don't enforce size constraints again
+  // here.
+  ConstrainSize(&size.width, &size.height);
+
+  if (mBounds.Size() == size) {
+    LOG("  Already the same size");
+    // mBounds was set at Create() or Resize().
+    if (mNeedsDispatchSize != LayoutDeviceIntSize(-1, -1)) {
+      LOG("  No longer needs to dispatch %dx%d", mNeedsDispatchSize.width,
+          mNeedsDispatchSize.height);
+      mNeedsDispatchSize = LayoutDeviceIntSize(-1, -1);
+    }
+    return;
+  }
+
+  // Invalidate the new part of the window now for the pending paint to
+  // minimize background flashes (GDK does not do this for external resizes
+  // of toplevels.)
+  if (mGdkWindow) {
+    if (mBounds.width < size.width) {
+      GdkRectangle rect = DevicePixelsToGdkRectRoundOut(LayoutDeviceIntRect(
+          mBounds.width, 0, size.width - mBounds.width, size.height));
+      gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
+    }
+    if (mBounds.height < size.height) {
+      GdkRectangle rect = DevicePixelsToGdkRectRoundOut(LayoutDeviceIntRect(
+          0, mBounds.height, size.width, size.height - mBounds.height));
+      gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
+    }
+  }
+
+  // If we update mBounds here, then inner/outerHeight are out of sync until
+  // we call WindowResized.
+  mNeedsDispatchSize = size;
+
+  // Gecko permits running nested event loops during processing of events,
+  // GtkWindow callers of gtk_widget_size_allocate expect the signal
+  // handlers to return sometime in the near future.
+  NS_DispatchToCurrentThread(NewRunnableMethod(
+      "nsWindow::MaybeDispatchResized", this, &nsWindow::MaybeDispatchResized));
+}
+
+void nsWindow::OnDeleteEvent() {
+  if (mWidgetListener) mWidgetListener->RequestWindowClose(this);
+}
+
+void nsWindow::OnEnterNotifyEvent(GdkEventCrossing* aEvent) {
+  LOG("enter notify (win=%p, sub=%p): %f, %f mode %d, detail %d\n",
+      aEvent->window, aEvent->subwindow, aEvent->x, aEvent->y, aEvent->mode,
+      aEvent->detail);
+  // This skips NotifyVirtual and NotifyNonlinearVirtual enter notify events
+  // when the pointer enters a child window.  If the destination window is a
+  // Gecko window then we'll catch the corresponding event on that window,
+  // but we won't notice when the pointer directly enters a foreign (plugin)
+  // child window without passing over a visible portion of a Gecko window.
+  if (aEvent->subwindow) {
+    return;
+  }
+
+  // Check before checking for ungrab as the button state may have
+  // changed while a non-Gecko ancestor window had a pointer grab.
+  DispatchMissedButtonReleases(aEvent);
+
+  WidgetMouseEvent event(true, eMouseEnterIntoWidget, this,
+                         WidgetMouseEvent::eReal);
+
+  event.mRefPoint = GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y);
+  event.AssignEventTime(GetWidgetEventTime(aEvent->time));
+
+  LOG("OnEnterNotify");
+
+  DispatchInputEvent(&event);
+}
+
+// Some window managers send a bogus top-level leave-notify event on every
+// click. That confuses our event handling code in ways that can break websites,
+// see bug 1805939 for details.
+//
+// Make sure to only check this on bogus environments, since for environments
+// with CSD, gdk_device_get_window_at_position could return the window even when
+// the pointer is in the decoration area.
+static bool IsBogusLeaveNotifyEvent(GdkWindow* aWindow,
+                                    GdkEventCrossing* aEvent) {
+  static bool sBogusWm = [] {
+    if (GdkIsWaylandDisplay()) {
+      return false;
+    }
+    const auto& desktopEnv = GetDesktopEnvironmentIdentifier();
+    return desktopEnv.EqualsLiteral("fluxbox") ||   // Bug 1805939 comment 0.
+           desktopEnv.EqualsLiteral("blackbox") ||  // Bug 1805939 comment 32.
+           StringBeginsWith(desktopEnv, "fvwm"_ns);
+  }();
+
+  const bool shouldCheck = [] {
+    switch (StaticPrefs::widget_gtk_ignore_bogus_leave_notify()) {
+      case 0:
+        return false;
+      case 1:
+        return true;
+      default:
+        return sBogusWm;
+    }
+  }();
+
+  if (!shouldCheck) {
+    return false;
+  }
+  GdkDevice* pointer = GdkGetPointer();
+  GdkWindow* winAtPt =
+      gdk_device_get_window_at_position(pointer, nullptr, nullptr);
+  if (!winAtPt) {
+    return false;
+  }
+  // We're still in the same top level window, ignore this leave notify event.
+  GdkWindow* topLevelAtPt = gdk_window_get_toplevel(winAtPt);
+  GdkWindow* topLevelWidget = gdk_window_get_toplevel(aWindow);
+  return topLevelAtPt == topLevelWidget;
+}
+
+void nsWindow::OnLeaveNotifyEvent(GdkEventCrossing* aEvent) {
+  LOG("leave notify (win=%p, sub=%p): %f, %f mode %d, detail %d\n",
+      aEvent->window, aEvent->subwindow, aEvent->x, aEvent->y, aEvent->mode,
+      aEvent->detail);
+
+  // This ignores NotifyVirtual and NotifyNonlinearVirtual leave notify
+  // events when the pointer leaves a child window.  If the destination
+  // window is a Gecko window then we'll catch the corresponding event on
+  // that window.
+  //
+  // XXXkt However, we will miss toplevel exits when the pointer directly
+  // leaves a foreign (plugin) child window without passing over a visible
+  // portion of a Gecko window.
+  if (aEvent->subwindow) {
+    return;
+  }
+
+  // The filter out for subwindows should make sure that this is targeted to
+  // this nsWindow.
+  const bool leavingTopLevel =
+      mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog;
+
+  if (leavingTopLevel && IsBogusLeaveNotifyEvent(mGdkWindow, aEvent)) {
+    return;
+  }
+
+  WidgetMouseEvent event(true, eMouseExitFromWidget, this,
+                         WidgetMouseEvent::eReal);
+
+  event.mRefPoint = GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y);
+  event.AssignEventTime(GetWidgetEventTime(aEvent->time));
+  event.mExitFrom = Some(leavingTopLevel ? WidgetMouseEvent::ePlatformTopLevel
+                                         : WidgetMouseEvent::ePlatformChild);
+
+  LOG("OnLeaveNotify");
+
+  DispatchInputEvent(&event);
+}
+
+bool nsWindow::CheckResizerEdge(LayoutDeviceIntPoint aPoint,
+                                GdkWindowEdge& aOutEdge) {
+  // We only need to handle resizers for PIP window.
+  if (!mIsPIPWindow) {
+    return false;
+  }
+
+  // Don't allow resizing maximized windows.
+  if (mSizeMode != nsSizeMode_Normal) {
+    return false;
+  }
+
+#define RESIZER_SIZE 15
+  int resizerSize = RESIZER_SIZE * GdkCeiledScaleFactor();
+  int topDist = aPoint.y;
+  int leftDist = aPoint.x;
+  int rightDist = mBounds.width - aPoint.x;
+  int bottomDist = mBounds.height - aPoint.y;
+
+  if (leftDist <= resizerSize && topDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_NORTH_WEST;
+  } else if (rightDist <= resizerSize && topDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_NORTH_EAST;
+  } else if (leftDist <= resizerSize && bottomDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_SOUTH_WEST;
+  } else if (rightDist <= resizerSize && bottomDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_SOUTH_EAST;
+  } else if (topDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_NORTH;
+  } else if (leftDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_WEST;
+  } else if (rightDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_EAST;
+  } else if (bottomDist <= resizerSize) {
+    aOutEdge = GDK_WINDOW_EDGE_SOUTH;
+  } else {
+    return false;
+  }
+  return true;
+}
+
+template <typename Event>
+static LayoutDeviceIntPoint GetRefPoint(nsWindow* aWindow, Event* aEvent) {
+  if (aEvent->window == aWindow->GetGdkWindow()) {
+    // we are the window that the event happened on so no need for expensive
+    // WidgetToScreenOffset
+    return aWindow->GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y);
+  }
+  // XXX we're never quite sure which GdkWindow the event came from due to our
+  // custom bubbling in scroll_event_cb(), so use ScreenToWidget to translate
+  // the screen root coordinates into coordinates relative to this widget.
+  return aWindow->GdkEventCoordsToDevicePixels(aEvent->x_root, aEvent->y_root) -
+         aWindow->WidgetToScreenOffset();
+}
+
+void nsWindow::OnMotionNotifyEvent(GdkEventMotion* aEvent) {
+  if (!mGdkWindow) {
+    return;
+  }
+
+  if (mWindowShouldStartDragging) {
+    mWindowShouldStartDragging = false;
+    // find the top-level window
+    GdkWindow* gdk_window = gdk_window_get_toplevel(mGdkWindow);
+    MOZ_ASSERT(gdk_window, "gdk_window_get_toplevel should not return null");
+
+    bool canDrag = true;
+#ifdef MOZ_X11
+    if (GdkIsX11Display()) {
+      // Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=789054
+      // To avoid crashes disable double-click on WM without _NET_WM_MOVERESIZE.
+      // See _should_perform_ewmh_drag() at gdkwindow-x11.c
+      GdkScreen* screen = gdk_window_get_screen(gdk_window);
+      GdkAtom atom = gdk_atom_intern("_NET_WM_MOVERESIZE", FALSE);
+      if (!gdk_x11_screen_supports_net_wm_hint(screen, atom)) {
+        canDrag = false;
+      }
+    }
+#endif
+
+    if (canDrag) {
+      gdk_window_begin_move_drag(gdk_window, 1, aEvent->x_root, aEvent->y_root,
+                                 aEvent->time);
+      return;
+    }
+  }
+
+  GdkWindowEdge edge;
+  const auto refPoint = GetRefPoint(this, aEvent);
+  if (CheckResizerEdge(refPoint, edge)) {
+    nsCursor cursor = eCursor_none;
+    switch (edge) {
+      case GDK_WINDOW_EDGE_NORTH:
+        cursor = eCursor_n_resize;
+        break;
+      case GDK_WINDOW_EDGE_NORTH_WEST:
+        cursor = eCursor_nw_resize;
+        break;
+      case GDK_WINDOW_EDGE_NORTH_EAST:
+        cursor = eCursor_ne_resize;
+        break;
+      case GDK_WINDOW_EDGE_WEST:
+        cursor = eCursor_w_resize;
+        break;
+      case GDK_WINDOW_EDGE_EAST:
+        cursor = eCursor_e_resize;
+        break;
+      case GDK_WINDOW_EDGE_SOUTH:
+        cursor = eCursor_s_resize;
+        break;
+      case GDK_WINDOW_EDGE_SOUTH_WEST:
+        cursor = eCursor_sw_resize;
+        break;
+      case GDK_WINDOW_EDGE_SOUTH_EAST:
+        cursor = eCursor_se_resize;
+        break;
+    }
+    SetCursor(Cursor{cursor});
+    return;
+  }
+
+  WidgetMouseEvent event(true, eMouseMove, this, WidgetMouseEvent::eReal);
+
+  gdouble pressure = 0;
+  gdk_event_get_axis((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure);
+  // Sometime gdk generate 0 pressure value between normal values
+  // We have to ignore that and use last valid value
+  if (pressure) {
+    mLastMotionPressure = pressure;
+  }
+  event.mPressure = mLastMotionPressure;
+  event.mRefPoint = refPoint;
+  event.AssignEventTime(GetWidgetEventTime(aEvent->time));
+
+  KeymapWrapper::InitInputEvent(event, aEvent->state);
+
+  DispatchInputEvent(&event);
+}
+
+// If the automatic pointer grab on ButtonPress has deactivated before
+// ButtonRelease, and the mouse button is released while the pointer is not
+// over any a Gecko window, then the ButtonRelease event will not be received.
+// (A similar situation exists when the pointer is grabbed with owner_events
+// True as the ButtonRelease may be received on a foreign [plugin] window).
+// Use this method to check for released buttons when the pointer returns to a
+// Gecko window.
+void nsWindow::DispatchMissedButtonReleases(GdkEventCrossing* aGdkEvent) {
+  guint changed = aGdkEvent->state ^ gButtonState;
+  // Only consider button releases.
+  // (Ignore button presses that occurred outside Gecko.)
+  guint released = changed & gButtonState;
+  gButtonState = aGdkEvent->state;
+
+  // Loop over each button, excluding mouse wheel buttons 4 and 5 for which
+  // GDK ignores releases.
+  for (guint buttonMask = GDK_BUTTON1_MASK; buttonMask <= GDK_BUTTON3_MASK;
+       buttonMask <<= 1) {
+    if (released & buttonMask) {
+      int16_t buttonType;
+      switch (buttonMask) {
+        case GDK_BUTTON1_MASK:
+          buttonType = MouseButton::ePrimary;
+          break;
+        case GDK_BUTTON2_MASK:
+          buttonType = MouseButton::eMiddle;
+          break;
+        default:
+          NS_ASSERTION(buttonMask == GDK_BUTTON3_MASK,
+                       "Unexpected button mask");
+          buttonType = MouseButton::eSecondary;
+      }
+
+      LOG("Synthesized button %u release", guint(buttonType + 1));
+
+      // Dispatch a synthesized button up event to tell Gecko about the
+      // change in state.  This event is marked as synthesized so that
+      // it is not dispatched as a DOM event, because we don't know the
+      // position, widget, modifiers, or time/order.
+      WidgetMouseEvent synthEvent(true, eMouseUp, this,
+                                  WidgetMouseEvent::eSynthesized);
+      synthEvent.mButton = buttonType;
+      DispatchInputEvent(&synthEvent);
+    }
+  }
+}
+
+void nsWindow::InitButtonEvent(WidgetMouseEvent& aEvent,
+                               GdkEventButton* aGdkEvent,
+                               const LayoutDeviceIntPoint& aRefPoint) {
+  aEvent.mRefPoint = aRefPoint;
+
+  guint modifierState = aGdkEvent->state;
+  // aEvent's state includes the button state from immediately before this
+  // event.  If aEvent is a mousedown or mouseup event, we need to update
+  // the button state.
+  guint buttonMask = 0;
+  switch (aGdkEvent->button) {
+    case 1:
+      buttonMask = GDK_BUTTON1_MASK;
+      break;
+    case 2:
+      buttonMask = GDK_BUTTON2_MASK;
+      break;
+    case 3:
+      buttonMask = GDK_BUTTON3_MASK;
+      break;
+  }
+  if (aGdkEvent->type == GDK_BUTTON_RELEASE) {
+    modifierState &= ~buttonMask;
+  } else {
+    modifierState |= buttonMask;
+  }
+
+  KeymapWrapper::InitInputEvent(aEvent, modifierState);
+
+  aEvent.AssignEventTime(GetWidgetEventTime(aGdkEvent->time));
+
+  switch (aGdkEvent->type) {
+    case GDK_2BUTTON_PRESS:
+      aEvent.mClickCount = 2;
+      break;
+    case GDK_3BUTTON_PRESS:
+      aEvent.mClickCount = 3;
+      break;
+      // default is one click
+    default:
+      aEvent.mClickCount = 1;
+  }
+}
+
+static guint ButtonMaskFromGDKButton(guint button) {
+  return GDK_BUTTON1_MASK << (button - 1);
+}
+
+void nsWindow::DispatchContextMenuEventFromMouseEvent(
+    uint16_t domButton, GdkEventButton* aEvent,
+    const LayoutDeviceIntPoint& aRefPoint) {
+  if (domButton == MouseButton::eSecondary && MOZ_LIKELY(!mIsDestroyed)) {
+    WidgetMouseEvent contextMenuEvent(true, eContextMenu, this,
+                                      WidgetMouseEvent::eReal);
+    InitButtonEvent(contextMenuEvent, aEvent, aRefPoint);
+    contextMenuEvent.mPressure = mLastMotionPressure;
+    DispatchInputEvent(&contextMenuEvent);
+  }
+}
+
+void nsWindow::TryToShowNativeWindowMenu(GdkEventButton* aEvent) {
+  if (!gdk_window_show_window_menu(GetToplevelGdkWindow(), (GdkEvent*)aEvent)) {
+    NS_WARNING("Native context menu wasn't shown");
+  }
+}
+
+void nsWindow::OnButtonPressEvent(GdkEventButton* aEvent) {
+  LOG("Button %u press\n", aEvent->button);
+
+  SetLastMousePressEvent((GdkEvent*)aEvent);
+
+  // If you double click in GDK, it will actually generate a second
+  // GDK_BUTTON_PRESS before sending the GDK_2BUTTON_PRESS, and this is
+  // different than the DOM spec.  GDK puts this in the queue
+  // programatically, so it's safe to assume that if there's a
+  // double click in the queue, it was generated so we can just drop
+  // this click.
+  GUniquePtr<GdkEvent> peekedEvent(gdk_event_peek());
+  if (peekedEvent) {
+    GdkEventType type = peekedEvent->any.type;
+    if (type == GDK_2BUTTON_PRESS || type == GDK_3BUTTON_PRESS) {
+      return;
+    }
+  }
+
+  nsWindow* containerWindow = GetContainerWindow();
+  if (!gFocusWindow && containerWindow) {
+    containerWindow->DispatchActivateEvent();
+  }
+
+  const auto refPoint = GetRefPoint(this, aEvent);
+
+  // check to see if we should rollup
+  if (CheckForRollup(aEvent->x_root, aEvent->y_root, false, false)) {
+    if (aEvent->button == 3 && mDraggableRegion.Contains(refPoint)) {
+      GUniquePtr<GdkEvent> eventCopy;
+      if (aEvent->type != GDK_BUTTON_PRESS) {
+        // If the user double-clicks too fast we'll get a 2BUTTON_PRESS event
+        // instead, and that isn't handled by open_window_menu, so coerce it
+        // into a regular press.
+        eventCopy.reset(gdk_event_copy((GdkEvent*)aEvent));
+        eventCopy->type = GDK_BUTTON_PRESS;
+      }
+      TryToShowNativeWindowMenu(eventCopy ? &eventCopy->button : aEvent);
+    }
+    return;
+  }
+
+  // Check to see if the event is within our window's resize region
+  GdkWindowEdge edge;
+  if (CheckResizerEdge(refPoint, edge)) {
+    gdk_window_begin_resize_drag(gtk_widget_get_window(mShell), edge,
+                                 aEvent->button, aEvent->x_root, aEvent->y_root,
+                                 aEvent->time);
+    return;
+  }
+
+  gdouble pressure = 0;
+  gdk_event_get_axis((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure);
+  mLastMotionPressure = pressure;
+
+  uint16_t domButton;
+  switch (aEvent->button) {
+    case 1:
+      domButton = MouseButton::ePrimary;
+      break;
+    case 2:
+      domButton = MouseButton::eMiddle;
+      break;
+    case 3:
+      domButton = MouseButton::eSecondary;
+      break;
+    // These are mapped to horizontal scroll
+    case 6:
+    case 7:
+      NS_WARNING("We're not supporting legacy horizontal scroll event");
+      return;
+    // Map buttons 8-9 to back/forward
+    case 8:
+      if (!Preferences::GetBool("mousebutton.4th.enabled", true)) {
+        return;
+      }
+      DispatchCommandEvent(nsGkAtoms::Back);
+      return;
+    case 9:
+      if (!Preferences::GetBool("mousebutton.5th.enabled", true)) {
+        return;
+      }
+      DispatchCommandEvent(nsGkAtoms::Forward);
+      return;
+    default:
+      return;
+  }
+
+  gButtonState |= ButtonMaskFromGDKButton(aEvent->button);
+
+  WidgetMouseEvent event(true, eMouseDown, this, WidgetMouseEvent::eReal);
+  event.mButton = domButton;
+  InitButtonEvent(event, aEvent, refPoint);
+  event.mPressure = mLastMotionPressure;
+
+  nsIWidget::ContentAndAPZEventStatus eventStatus = DispatchInputEvent(&event);
+
+  if ((mIsWaylandPanelWindow || mDraggableRegion.Contains(refPoint)) &&
+      domButton == MouseButton::ePrimary &&
+      eventStatus.mContentStatus != nsEventStatus_eConsumeNoDefault) {
+    mWindowShouldStartDragging = true;
+  }
+
+  // right menu click on linux should also pop up a context menu
+  if (!StaticPrefs::ui_context_menus_after_mouseup() &&
+      eventStatus.mApzStatus != nsEventStatus_eConsumeNoDefault) {
+    DispatchContextMenuEventFromMouseEvent(domButton, aEvent, refPoint);
+  }
+}
+
+void nsWindow::OnButtonReleaseEvent(GdkEventButton* aEvent) {
+  LOG("Button %u release\n", aEvent->button);
+
+  SetLastMousePressEvent(nullptr);
+
+  if (!mGdkWindow) {
+    return;
+  }
+
+  if (mWindowShouldStartDragging) {
+    mWindowShouldStartDragging = false;
+  }
+
+  uint16_t domButton;
+  switch (aEvent->button) {
+    case 1:
+      domButton = MouseButton::ePrimary;
+      break;
+    case 2:
+      domButton = MouseButton::eMiddle;
+      break;
+    case 3:
+      domButton = MouseButton::eSecondary;
+      break;
+    default:
+      return;
+  }
+
+  gButtonState &= ~ButtonMaskFromGDKButton(aEvent->button);
+
+  const auto refPoint = GetRefPoint(this, aEvent);
+
+  WidgetMouseEvent event(true, eMouseUp, this, WidgetMouseEvent::eReal);
+  event.mButton = domButton;
+  InitButtonEvent(event, aEvent, refPoint);
+  gdouble pressure = 0;
+  gdk_event_get_axis((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure);
+  event.mPressure = pressure ? (float)pressure : (float)mLastMotionPressure;
+
+  // The mRefPoint is manipulated in DispatchInputEvent, we're saving it
+  // to use it for the doubleclick position check.
+  const LayoutDeviceIntPoint pos = event.mRefPoint;
+
+  nsIWidget::ContentAndAPZEventStatus eventStatus = DispatchInputEvent(&event);
+
+  const bool defaultPrevented =
+      eventStatus.mContentStatus == nsEventStatus_eConsumeNoDefault;
+  // Check if mouse position in titlebar and doubleclick happened to
+  // trigger restore/maximize.
+  if (!defaultPrevented && mDrawInTitlebar &&
+      event.mButton == MouseButton::ePrimary && event.mClickCount == 2 &&
+      mDraggableRegion.Contains(pos)) {
+    if (mSizeMode == nsSizeMode_Maximized) {
+      SetSizeMode(nsSizeMode_Normal);
+    } else if (mSizeMode == nsSizeMode_Normal) {
+      SetSizeMode(nsSizeMode_Maximized);
+    }
+  }
+  mLastMotionPressure = pressure;
+
+  // right menu click on linux should also pop up a context menu
+  if (StaticPrefs::ui_context_menus_after_mouseup() &&
+      eventStatus.mApzStatus != nsEventStatus_eConsumeNoDefault) {
+    DispatchContextMenuEventFromMouseEvent(domButton, aEvent, refPoint);
+  }
+
+  // Open window manager menu on PIP window to allow user
+  // to place it on top / all workspaces.
+  if (mIsPIPWindow && aEvent->button == 3) {
+    TryToShowNativeWindowMenu(aEvent);
+  }
+}
+
+void nsWindow::OnContainerFocusInEvent(GdkEventFocus* aEvent) {
+  LOG("OnContainerFocusInEvent");
+
+  // Unset the urgency hint, if possible
+  GtkWidget* top_window = GetToplevelWidget();
+  if (top_window && (gtk_widget_get_visible(top_window))) {
+    SetUrgencyHint(top_window, false);
+  }
+
+  // Return if being called within SetFocus because the focus manager
+  // already knows that the window is active.
+  if (gBlockActivateEvent) {
+    LOG("activated notification is blocked");
+    return;
+  }
+
+  // If keyboard input will be accepted, the focus manager will call
+  // SetFocus to set the correct window.
+  gFocusWindow = nullptr;
+
+  DispatchActivateEvent();
+
+  if (!gFocusWindow) {
+    // We don't really have a window for dispatching key events, but
+    // setting a non-nullptr value here prevents OnButtonPressEvent() from
+    // dispatching an activation notification if the widget is already
+    // active.
+    gFocusWindow = this;
+  }
+
+  LOG("Events sent from focus in event");
+}
+
+void nsWindow::OnContainerFocusOutEvent(GdkEventFocus* aEvent) {
+  LOG("OnContainerFocusOutEvent");
+
+  if (mWindowType == eWindowType_toplevel ||
+      mWindowType == eWindowType_dialog) {
+    nsCOMPtr<nsIDragService> dragService =
+        do_GetService("@mozilla.org/widget/dragservice;1");
+    nsCOMPtr<nsIDragSession> dragSession;
+    dragService->GetCurrentSession(getter_AddRefs(dragSession));
+
+    // Rollup popups when a window is focused out unless a drag is occurring.
+    // This check is because drags grab the keyboard and cause a focus out on
+    // versions of GTK before 2.18.
+    bool shouldRollup = !dragSession;
+    if (!shouldRollup) {
+      // we also roll up when a drag is from a different application
+      nsCOMPtr<nsINode> sourceNode;
+      dragSession->GetSourceNode(getter_AddRefs(sourceNode));
+      shouldRollup = (sourceNode == nullptr);
+    }
+
+    if (shouldRollup) {
+      CheckForRollup(0, 0, false, true);
+    }
+  }
+
+  if (gFocusWindow) {
+    RefPtr<nsWindow> kungFuDeathGrip = gFocusWindow;
+    if (gFocusWindow->mIMContext) {
+      gFocusWindow->mIMContext->OnBlurWindow(gFocusWindow);
+    }
+    gFocusWindow = nullptr;
+  }
+
+  DispatchDeactivateEvent();
+
+  if (IsChromeWindowTitlebar()) {
+    // DispatchDeactivateEvent() ultimately results in a call to
+    // BrowsingContext::SetIsActiveBrowserWindow(), which resets
+    // the state.  We call UpdateMozWindowActive() to keep it in
+    // sync with GDK_WINDOW_STATE_FOCUSED.
+    UpdateMozWindowActive();
+  }
+
+  LOG("Done with container focus out");
+}
+
+bool nsWindow::DispatchCommandEvent(nsAtom* aCommand) {
+  nsEventStatus status;
+  WidgetCommandEvent appCommandEvent(true, aCommand, this);
+  DispatchEvent(&appCommandEvent, status);
+  return TRUE;
+}
+
+bool nsWindow::DispatchContentCommandEvent(EventMessage aMsg) {
+  nsEventStatus status;
+  WidgetContentCommandEvent event(true, aMsg, this);
+  DispatchEvent(&event, status);
+  return TRUE;
+}
+
+WidgetEventTime nsWindow::GetWidgetEventTime(guint32 aEventTime) {
+  return WidgetEventTime(GetEventTimeStamp(aEventTime));
+}
+
+TimeStamp nsWindow::GetEventTimeStamp(guint32 aEventTime) {
+  if (MOZ_UNLIKELY(!mGdkWindow)) {
+    // nsWindow has been Destroy()ed.
+    return TimeStamp::Now();
+  }
+  if (aEventTime == 0) {
+    // Some X11 and GDK events may be received with a time of 0 to indicate
+    // that they are synthetic events. Some input method editors do this.
+    // In this case too, just return the current timestamp.
+    return TimeStamp::Now();
+  }
+
+  TimeStamp eventTimeStamp;
+
+  if (GdkIsWaylandDisplay()) {
+    // Wayland compositors use monotonic time to set timestamps.
+    int64_t timestampTime = g_get_monotonic_time() / 1000;
+    guint32 refTimeTruncated = guint32(timestampTime);
+
+    timestampTime -= refTimeTruncated - aEventTime;
+    int64_t tick =
+        BaseTimeDurationPlatformUtils::TicksFromMilliseconds(timestampTime);
+    eventTimeStamp = TimeStamp::FromSystemTime(tick);
+  } else {
+#ifdef MOZ_X11
+    CurrentX11TimeGetter* getCurrentTime = GetCurrentTimeGetter();
+    MOZ_ASSERT(getCurrentTime,
+               "Null current time getter despite having a window");
+    eventTimeStamp =
+        TimeConverter().GetTimeStampFromSystemTime(aEventTime, *getCurrentTime);
+#endif
+  }
+  return eventTimeStamp;
+}
+
+#ifdef MOZ_X11
+mozilla::CurrentX11TimeGetter* nsWindow::GetCurrentTimeGetter() {
+  MOZ_ASSERT(mGdkWindow, "Expected mGdkWindow to be set");
+  if (MOZ_UNLIKELY(!mCurrentTimeGetter)) {
+    mCurrentTimeGetter = MakeUnique<CurrentX11TimeGetter>(mGdkWindow);
+  }
+  return mCurrentTimeGetter.get();
+}
+#endif
+
+gboolean nsWindow::OnKeyPressEvent(GdkEventKey* aEvent) {
+  LOG("OnKeyPressEvent");
+
+  KeymapWrapper::HandleKeyPressEvent(this, aEvent);
+  return TRUE;
+}
+
+gboolean nsWindow::OnKeyReleaseEvent(GdkEventKey* aEvent) {
+  LOG("OnKeyReleaseEvent");
+  if (NS_WARN_IF(!KeymapWrapper::HandleKeyReleaseEvent(this, aEvent))) {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+void nsWindow::OnScrollEvent(GdkEventScroll* aEvent) {
+  // check to see if we should rollup
+  if (CheckForRollup(aEvent->x_root, aEvent->y_root, true, false)) {
+    return;
+  }
+
+  // check for duplicate legacy scroll event, see GNOME bug 726878
+  if (aEvent->direction != GDK_SCROLL_SMOOTH &&
+      mLastScrollEventTime == aEvent->time) {
+    LOG("[%d] duplicate legacy scroll event %d\n", aEvent->time,
+        aEvent->direction);
+    return;
+  }
+  WidgetWheelEvent wheelEvent(true, eWheel, this);
+  wheelEvent.mDeltaMode = dom::WheelEvent_Binding::DOM_DELTA_LINE;
+  switch (aEvent->direction) {
+    case GDK_SCROLL_SMOOTH: {
+      // As of GTK 3.4, all directional scroll events are provided by
+      // the GDK_SCROLL_SMOOTH direction on XInput2 and Wayland devices.
+      mLastScrollEventTime = aEvent->time;
+
+      // Special handling for touchpads to support flings
+      // (also known as kinetic/inertial/momentum scrolling)
+      GdkDevice* device = gdk_event_get_source_device((GdkEvent*)aEvent);
+      GdkInputSource source = gdk_device_get_source(device);
+      if (source == GDK_SOURCE_TOUCHSCREEN || source == GDK_SOURCE_TOUCHPAD ||
+          mCurrentSynthesizedTouchpadPan.mTouchpadGesturePhase.isSome()) {
+        if (StaticPrefs::apz_gtk_pangesture_enabled() &&
+            gtk_check_version(3, 20, 0) == nullptr) {
+          static auto sGdkEventIsScrollStopEvent =
+              (gboolean(*)(const GdkEvent*))dlsym(
+                  RTLD_DEFAULT, "gdk_event_is_scroll_stop_event");
+
+          LOG("[%d] pan smooth event dx=%f dy=%f inprogress=%d\n", aEvent->time,
+              aEvent->delta_x, aEvent->delta_y, mPanInProgress);
+          PanGestureInput::PanGestureType eventType =
+              PanGestureInput::PANGESTURE_PAN;
+          if (sGdkEventIsScrollStopEvent((GdkEvent*)aEvent)) {
+            eventType = PanGestureInput::PANGESTURE_END;
+            mPanInProgress = false;
+          } else if (!mPanInProgress) {
+            eventType = PanGestureInput::PANGESTURE_START;
+            mPanInProgress = true;
+          } else if (mCurrentSynthesizedTouchpadPan.mTouchpadGesturePhase
+                         .isSome()) {
+            switch (*mCurrentSynthesizedTouchpadPan.mTouchpadGesturePhase) {
+              case PHASE_BEGIN:
+                // we should never hit this because we'll hit the above case
+                // before this.
+                MOZ_ASSERT_UNREACHABLE();
+                eventType = PanGestureInput::PANGESTURE_START;
+                mPanInProgress = true;
+                break;
+              case PHASE_UPDATE:
+                // nothing to do here, eventtype should already be set
+                MOZ_ASSERT(mPanInProgress);
+                MOZ_ASSERT(eventType == PanGestureInput::PANGESTURE_PAN);
+                eventType = PanGestureInput::PANGESTURE_PAN;
+                break;
+              case PHASE_END:
+                MOZ_ASSERT(mPanInProgress);
+                eventType = PanGestureInput::PANGESTURE_END;
+                mPanInProgress = false;
+                break;
+              default:
+                MOZ_ASSERT_UNREACHABLE();
+                break;
+            }
+          }
+
+          mCurrentSynthesizedTouchpadPan.mTouchpadGesturePhase.reset();
+
+          const bool isPageMode =
+              StaticPrefs::apz_gtk_pangesture_delta_mode() != 2;
+          const double multiplier =
+              isPageMode
+                  ? StaticPrefs::apz_gtk_pangesture_page_delta_mode_multiplier()
+                  : StaticPrefs::
+                            apz_gtk_pangesture_pixel_delta_mode_multiplier() *
+                        FractionalScaleFactor();
+
+          ScreenPoint deltas(float(aEvent->delta_x * multiplier),
+                             float(aEvent->delta_y * multiplier));
+
+          LayoutDeviceIntPoint touchPoint = GetRefPoint(this, aEvent);
+          PanGestureInput panEvent(
+              eventType, GetEventTimeStamp(aEvent->time),
+              ScreenPoint(touchPoint.x, touchPoint.y), deltas,
+              KeymapWrapper::ComputeKeyModifiers(aEvent->state));
+          panEvent.mDeltaType = isPageMode ? PanGestureInput::PANDELTA_PAGE
+                                           : PanGestureInput::PANDELTA_PIXEL;
+          panEvent.mSimulateMomentum =
+              StaticPrefs::apz_gtk_kinetic_scroll_enabled();
+
+          DispatchPanGesture(panEvent);
+
+          if (mCurrentSynthesizedTouchpadPan.mSavedObserver != 0) {
+            mozilla::widget::AutoObserverNotifier::NotifySavedObserver(
+                mCurrentSynthesizedTouchpadPan.mSavedObserver,
+                "touchpadpanevent");
+            mCurrentSynthesizedTouchpadPan.mSavedObserver = 0;
+          }
+
+          return;
+        }
+
+        // Older GTK doesn't support stop events, so we can't support fling
+        wheelEvent.mScrollType = WidgetWheelEvent::SCROLL_ASYNCHRONOUSLY;
+      }
+
+      // TODO - use a more appropriate scrolling unit than lines.
+      // Multiply event deltas by 3 to emulate legacy behaviour.
+      wheelEvent.mDeltaX = aEvent->delta_x * 3;
+      wheelEvent.mDeltaY = aEvent->delta_y * 3;
+      wheelEvent.mWheelTicksX = aEvent->delta_x;
+      wheelEvent.mWheelTicksY = aEvent->delta_y;
+      wheelEvent.mIsNoLineOrPageDelta = true;
+
+      break;
+    }
+    case GDK_SCROLL_UP:
+      wheelEvent.mDeltaY = wheelEvent.mLineOrPageDeltaY = -3;
+      wheelEvent.mWheelTicksY = -1;
+      break;
+    case GDK_SCROLL_DOWN:
+      wheelEvent.mDeltaY = wheelEvent.mLineOrPageDeltaY = 3;
+      wheelEvent.mWheelTicksY = 1;
+      break;
+    case GDK_SCROLL_LEFT:
+      wheelEvent.mDeltaX = wheelEvent.mLineOrPageDeltaX = -1;
+      wheelEvent.mWheelTicksX = -1;
+      break;
+    case GDK_SCROLL_RIGHT:
+      wheelEvent.mDeltaX = wheelEvent.mLineOrPageDeltaX = 1;
+      wheelEvent.mWheelTicksX = 1;
+      break;
+  }
+
+  wheelEvent.mRefPoint = GetRefPoint(this, aEvent);
+
+  KeymapWrapper::InitInputEvent(wheelEvent, aEvent->state);
+
+  wheelEvent.AssignEventTime(GetWidgetEventTime(aEvent->time));
+
+  DispatchInputEvent(&wheelEvent);
+}
+
+void nsWindow::DispatchPanGesture(PanGestureInput& aPanInput) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mSwipeTracker) {
+    // Give the swipe tracker a first pass at the event. If a new pan gesture
+    // has been started since the beginning of the swipe, the swipe tracker
+    // will know to ignore the event.
+    nsEventStatus status = mSwipeTracker->ProcessEvent(aPanInput);
+    if (status == nsEventStatus_eConsumeNoDefault) {
+      return;
+    }
+  }
+
+  APZEventResult result;
+  if (mAPZC) {
+    MOZ_ASSERT(APZThreadUtils::IsControllerThread());
+
+    result = mAPZC->InputBridge()->ReceiveInputEvent(aPanInput);
+    if (result.GetStatus() == nsEventStatus_eConsumeNoDefault) {
+      return;
+    }
+  }
+
+  WidgetWheelEvent event = aPanInput.ToWidgetEvent(this);
+  if (!mAPZC) {
+    if (MayStartSwipeForNonAPZ(aPanInput)) {
+      return;
+    }
+  } else {
+    event = MayStartSwipeForAPZ(aPanInput, result);
+  }
+
+  ProcessUntransformedAPZEvent(&event, result);
+}
+
+void nsWindow::OnWindowStateEvent(GtkWidget* aWidget,
+                                  GdkEventWindowState* aEvent) {
+  LOG("nsWindow::OnWindowStateEvent for %p changed 0x%x new_window_state "
+      "0x%x\n",
+      aWidget, aEvent->changed_mask, aEvent->new_window_state);
+
+  if (IS_MOZ_CONTAINER(aWidget)) {
+    // This event is notifying the container widget of changes to the
+    // toplevel window.  Just detect changes affecting whether windows are
+    // viewable.
+    //
+    // (A visibility notify event is sent to each window that becomes
+    // viewable when the toplevel is mapped, but we can't rely on that for
+    // setting mHasMappedToplevel because these toplevel window state
+    // events are asynchronous.  The windows in the hierarchy now may not
+    // be the same windows as when the toplevel was mapped, so they may
+    // not get VisibilityNotify events.)
+    bool mapped = !(aEvent->new_window_state &
+                    (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_WITHDRAWN));
+    SetHasMappedToplevel(mapped);
+    LOG("\tquick return because IS_MOZ_CONTAINER(aWidget) is true\n");
+    return;
+  }
+  // else the widget is a shell widget.
+
+  // The block below is a bit evil.
+  //
+  // When a window is resized before it is shown, gtk_window_resize() delays
+  // resizes until the window is shown.  If gtk_window_state_event() sees a
+  // GDK_WINDOW_STATE_MAXIMIZED change [1] before the window is shown, then
+  // gtk_window_compute_configure_request_size() ignores the values from the
+  // resize [2].  See bug 1449166 for an example of how this could happen.
+  //
+  // [1] https://gitlab.gnome.org/GNOME/gtk/blob/3.22.30/gtk/gtkwindow.c#L7967
+  // [2] https://gitlab.gnome.org/GNOME/gtk/blob/3.22.30/gtk/gtkwindow.c#L9377
+  //
+  // In order to provide a sensible size for the window when the user exits
+  // maximized state, we hide the GDK_WINDOW_STATE_MAXIMIZED change from
+  // gtk_window_state_event() so as to trick GTK into using the values from
+  // gtk_window_resize() in its configure request.
+  //
+  // We instead notify gtk_window_state_event() of the maximized state change
+  // once the window is shown.
+  //
+  // See https://gitlab.gnome.org/GNOME/gtk/issues/1044
+  //
+  // This may be fixed in Gtk 3.24+ but it's still live and kicking
+  // (Bug 1791779).
+  if (!mIsShown) {
+    aEvent->changed_mask = static_cast<GdkWindowState>(
+        aEvent->changed_mask & ~GDK_WINDOW_STATE_MAXIMIZED);
+  } else if (aEvent->changed_mask & GDK_WINDOW_STATE_WITHDRAWN &&
+             aEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) {
+    aEvent->changed_mask = static_cast<GdkWindowState>(
+        aEvent->changed_mask | GDK_WINDOW_STATE_MAXIMIZED);
+  }
+
+  // This is a workaround for https://gitlab.gnome.org/GNOME/gtk/issues/1395
+  // Gtk+ controls window active appearance by window-state-event signal.
+  if (IsChromeWindowTitlebar() &&
+      (aEvent->changed_mask & GDK_WINDOW_STATE_FOCUSED)) {
+    // Emulate what Gtk+ does at gtk_window_state_event().
+    // We can't check GTK_STATE_FLAG_BACKDROP directly as it's set by Gtk+
+    // *after* this window-state-event handler.
+    mTitlebarBackdropState =
+        !(aEvent->new_window_state & GDK_WINDOW_STATE_FOCUSED);
+
+    // keep IsActiveBrowserWindow in sync with GDK_WINDOW_STATE_FOCUSED
+    UpdateMozWindowActive();
+
+    ForceTitlebarRedraw();
+  }
+
+  // We don't care about anything but changes in the maximized/icon/fullscreen
+  // states but we need a workaround for bug in Wayland:
+  // https://gitlab.gnome.org/GNOME/gtk/issues/67
+  // Under wayland the gtk_window_iconify implementation does NOT synthetize
+  // window_state_event where the GDK_WINDOW_STATE_ICONIFIED is set.
+  // During restore we  won't get aEvent->changed_mask with
+  // the GDK_WINDOW_STATE_ICONIFIED so to detect that change we use the stored
+  // mSizeMode and obtaining a focus.
+  bool waylandWasIconified =
+      (GdkIsWaylandDisplay() &&
+       aEvent->changed_mask & GDK_WINDOW_STATE_FOCUSED &&
+       aEvent->new_window_state & GDK_WINDOW_STATE_FOCUSED &&
+       mSizeMode == nsSizeMode_Minimized);
+  if (!waylandWasIconified &&
+      (aEvent->changed_mask &
+       (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_MAXIMIZED |
+        GDK_WINDOW_STATE_TILED | GDK_WINDOW_STATE_FULLSCREEN)) == 0) {
+    LOG("\tearly return because no interesting bits changed\n");
+    return;
+  }
+
+  auto oldSizeMode = mSizeMode;
+  if (aEvent->new_window_state & GDK_WINDOW_STATE_ICONIFIED) {
+    LOG("\tIconified\n");
+    mSizeMode = nsSizeMode_Minimized;
+#ifdef ACCESSIBILITY
+    DispatchMinimizeEventAccessible();
+#endif  // ACCESSIBILITY
+  } else if (aEvent->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
+    LOG("\tFullscreen\n");
+    mSizeMode = nsSizeMode_Fullscreen;
+  } else if (aEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) {
+    LOG("\tMaximized\n");
+    mSizeMode = nsSizeMode_Maximized;
+#ifdef ACCESSIBILITY
+    DispatchMaximizeEventAccessible();
+#endif  // ACCESSIBILITY
+  } else {
+    LOG("\tNormal\n");
+    mSizeMode = nsSizeMode_Normal;
+#ifdef ACCESSIBILITY
+    DispatchRestoreEventAccessible();
+#endif  // ACCESSIBILITY
+  }
+
+  mIsTiled = aEvent->new_window_state & GDK_WINDOW_STATE_TILED;
+  LOG("\tTiled: %d\n", int(mIsTiled));
+
+  if (mWidgetListener && mSizeMode != oldSizeMode) {
+    if (mSizeMode == nsSizeMode_Fullscreen ||
+        oldSizeMode == nsSizeMode_Fullscreen) {
+      bool isFullscreen = mSizeMode == nsSizeMode_Fullscreen;
+      mWidgetListener->FullscreenWillChange(isFullscreen);
+      mWidgetListener->SizeModeChanged(mSizeMode);
+      mWidgetListener->FullscreenChanged(isFullscreen);
+    } else {
+      mWidgetListener->SizeModeChanged(mSizeMode);
+    }
+  }
+
+  if (mDrawInTitlebar && mTransparencyBitmapForTitlebar) {
+    if (mSizeMode == nsSizeMode_Normal && !mIsTiled) {
+      UpdateTitlebarTransparencyBitmap();
+    } else {
+      ClearTransparencyBitmap();
+    }
+  }
+}
+
+void nsWindow::OnDPIChanged() {
+  // Update menu's font size etc.
+  // This affects style / layout because it affects system font sizes.
+  if (mWidgetListener) {
+    if (PresShell* presShell = mWidgetListener->GetPresShell()) {
+      presShell->BackingScaleFactorChanged();
+    }
+    mWidgetListener->UIResolutionChanged();
+  }
+  NotifyThemeChanged(ThemeChangeKind::StyleAndLayout);
+}
+
+void nsWindow::OnCheckResize() { mPendingConfigures++; }
+
+void nsWindow::OnCompositedChanged() {
+  // Update CSD after the change in alpha visibility. This only affects
+  // system metrics, not other theme shenanigans.
+  NotifyThemeChanged(ThemeChangeKind::MediaQueriesOnly);
+  mCompositedScreen = gdk_screen_is_composited(gdk_screen_get_default());
+}
+
+void nsWindow::OnScaleChanged() {
+  // Force scale factor recalculation
+  if (!mGdkWindow) {
+    mWindowScaleFactorChanged = true;
+    return;
+  }
+  LOG("OnScaleChanged -> %d\n", gdk_window_get_scale_factor(mGdkWindow));
+
+  // Gtk supply us sometimes with doubled events so stay calm in such case.
+  if (gdk_window_get_scale_factor(mGdkWindow) == mWindowScaleFactor) {
+    return;
+  }
+
+  // We pause compositor to avoid rendering of obsoleted remote content which
+  // produces flickering.
+  // Re-enable compositor again when remote content is updated or
+  // timeout happens.
+  PauseCompositorFlickering();
+
+  // Force scale factor recalculation
+  mWindowScaleFactorChanged = true;
+
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(GTK_WIDGET(mContainer), &allocation);
+  LayoutDeviceIntSize size = GdkRectToDevicePixels(allocation).Size();
+  mBounds.SizeTo(size);
+  // Check mBounds size
+  if (mCompositorSession &&
+      !wr::WindowSizeSanityCheck(mBounds.width, mBounds.height)) {
+    gfxCriticalNoteOnce << "Invalid mBounds in OnScaleChanged " << mBounds;
+  }
+
+  if (mWidgetListener) {
+    if (PresShell* presShell = mWidgetListener->GetPresShell()) {
+      presShell->BackingScaleFactorChanged();
+    }
+  }
+  // This affects style / layout because it affects system font sizes.
+  // Update menu's font size etc.
+  NotifyThemeChanged(ThemeChangeKind::StyleAndLayout);
+
+  DispatchResized();
+
+  if (mCompositorWidgetDelegate) {
+    mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize());
+  }
+
+  if (mCursor.IsCustom()) {
+    mUpdateCursor = true;
+    SetCursor(Cursor{mCursor});
+  }
+}
+
+void nsWindow::DispatchDragEvent(EventMessage aMsg,
+                                 const LayoutDeviceIntPoint& aRefPoint,
+                                 guint aTime) {
+  LOGDRAG("nsWindow::DispatchDragEvent");
+  WidgetDragEvent event(true, aMsg, this);
+
+  InitDragEvent(event);
+
+  event.mRefPoint = aRefPoint;
+  event.AssignEventTime(GetWidgetEventTime(aTime));
+
+  DispatchInputEvent(&event);
+}
+
+void nsWindow::OnDragDataReceivedEvent(GtkWidget* aWidget,
+                                       GdkDragContext* aDragContext, gint aX,
+                                       gint aY,
+                                       GtkSelectionData* aSelectionData,
+                                       guint aInfo, guint aTime,
+                                       gpointer aData) {
+  LOGDRAG("nsWindow::OnDragDataReceived");
+
+  RefPtr<nsDragService> dragService = nsDragService::GetInstance();
+  nsDragService::AutoEventLoop loop(dragService);
+  dragService->TargetDataReceived(aWidget, aDragContext, aX, aY, aSelectionData,
+                                  aInfo, aTime);
+}
+
+nsWindow* nsWindow::GetTransientForWindowIfPopup() {
+  if (mWindowType != eWindowType_popup) {
+    return nullptr;
+  }
+  GtkWindow* toplevel = gtk_window_get_transient_for(GTK_WINDOW(mShell));
+  if (toplevel) {
+    return get_window_for_gtk_widget(GTK_WIDGET(toplevel));
+  }
+  return nullptr;
+}
+
+bool nsWindow::IsHandlingTouchSequence(GdkEventSequence* aSequence) {
+  return mHandleTouchEvent && mTouches.Contains(aSequence);
+}
+
+gboolean nsWindow::OnTouchpadPinchEvent(GdkEventTouchpadPinch* aEvent) {
+  if (!StaticPrefs::apz_gtk_touchpad_pinch_enabled()) {
+    return TRUE;
+  }
+  // Do not respond to pinch gestures involving more than two fingers
+  // unless specifically preffed on. These are sometimes hooked up to other
+  // actions at the desktop environment level and having the browser also
+  // pinch can be undesirable.
+  if (aEvent->n_fingers > 2 &&
+      !StaticPrefs::apz_gtk_touchpad_pinch_three_fingers_enabled()) {
+    return FALSE;
+  }
+  auto pinchGestureType = PinchGestureInput::PINCHGESTURE_SCALE;
+  ScreenCoord currentSpan;
+  ScreenCoord previousSpan;
+
+  switch (aEvent->phase) {
+    case GDK_TOUCHPAD_GESTURE_PHASE_BEGIN:
+      pinchGestureType = PinchGestureInput::PINCHGESTURE_START;
+      currentSpan = aEvent->scale;
+      mCurrentTouchpadFocus = ViewAs<ScreenPixel>(
+          GetRefPoint(this, aEvent),
+          PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
+
+      // Assign PreviousSpan --> 0.999 to make mDeltaY field of the
+      // WidgetWheelEvent that this PinchGestureInput event will be converted
+      // to not equal Zero as our discussion because we observed that the
+      // scale of the PHASE_BEGIN event is 1.
+      previousSpan = 0.999;
+      break;
+
+    case GDK_TOUCHPAD_GESTURE_PHASE_UPDATE:
+      pinchGestureType = PinchGestureInput::PINCHGESTURE_SCALE;
+      mCurrentTouchpadFocus += ScreenPoint(aEvent->dx, aEvent->dy);
+      if (aEvent->scale == mLastPinchEventSpan) {
+        return FALSE;
+      }
+      currentSpan = aEvent->scale;
+      previousSpan = mLastPinchEventSpan;
+      break;
+
+    case GDK_TOUCHPAD_GESTURE_PHASE_END:
+      pinchGestureType = PinchGestureInput::PINCHGESTURE_END;
+      currentSpan = aEvent->scale;
+      previousSpan = mLastPinchEventSpan;
+      break;
+
+    default:
+      return FALSE;
+  }
+
+  PinchGestureInput event(
+      pinchGestureType, PinchGestureInput::TRACKPAD,
+      GetEventTimeStamp(aEvent->time), ExternalPoint(0, 0),
+      mCurrentTouchpadFocus,
+      100.0 * ((aEvent->phase == GDK_TOUCHPAD_GESTURE_PHASE_END)
+                   ? ScreenCoord(1.f)
+                   : currentSpan),
+      100.0 * ((aEvent->phase == GDK_TOUCHPAD_GESTURE_PHASE_END)
+                   ? ScreenCoord(1.f)
+                   : previousSpan),
+      KeymapWrapper::ComputeKeyModifiers(aEvent->state));
+
+  if (!event.SetLineOrPageDeltaY(this)) {
+    return FALSE;
+  }
+
+  mLastPinchEventSpan = aEvent->scale;
+  DispatchPinchGestureInput(event);
+  return TRUE;
+}
+
+gboolean nsWindow::OnTouchEvent(GdkEventTouch* aEvent) {
+  LOG("OnTouchEvent: x=%f y=%f type=%d\n", aEvent->x, aEvent->y, aEvent->type);
+  if (!mHandleTouchEvent) {
+    // If a popup window was spawned (e.g. as the result of a long-press)
+    // and touch events got diverted to that window within a touch sequence,
+    // ensure the touch event gets sent to the original window instead. We
+    // keep the checks here very conservative so that we only redirect
+    // events in this specific scenario.
+    nsWindow* targetWindow = GetTransientForWindowIfPopup();
+    if (targetWindow &&
+        targetWindow->IsHandlingTouchSequence(aEvent->sequence)) {
+      return targetWindow->OnTouchEvent(aEvent);
+    }
+
+    return FALSE;
+  }
+
+  EventMessage msg;
+  switch (aEvent->type) {
+    case GDK_TOUCH_BEGIN:
+      // check to see if we should rollup
+      if (CheckForRollup(aEvent->x_root, aEvent->y_root, false, false)) {
+        return FALSE;
+      }
+      msg = eTouchStart;
+      break;
+    case GDK_TOUCH_UPDATE:
+      msg = eTouchMove;
+      // Start dragging when motion events happens in the dragging area
+      if (mWindowShouldStartDragging) {
+        mWindowShouldStartDragging = false;
+        GdkWindow* gdk_window = gdk_window_get_toplevel(mGdkWindow);
+        MOZ_ASSERT(gdk_window,
+                   "gdk_window_get_toplevel should not return null");
+
+        LOG("  start window dragging window\n");
+        gdk_window_begin_move_drag(gdk_window, 1, aEvent->x_root,
+                                   aEvent->y_root, aEvent->time);
+
+        // Cancel the event sequence. gdk will steal all subsequent events
+        // (including TOUCH_END).
+        msg = eTouchCancel;
+      }
+      break;
+    case GDK_TOUCH_END:
+      msg = eTouchEnd;
+      if (mWindowShouldStartDragging) {
+        LOG("  end of window dragging window\n");
+        mWindowShouldStartDragging = false;
+      }
+      break;
+    case GDK_TOUCH_CANCEL:
+      msg = eTouchCancel;
+      break;
+    default:
+      return FALSE;
+  }
+
+  const LayoutDeviceIntPoint touchPoint = GetRefPoint(this, aEvent);
+
+  int32_t id;
+  RefPtr<dom::Touch> touch;
+  if (mTouches.Remove(aEvent->sequence, getter_AddRefs(touch))) {
+    id = touch->mIdentifier;
+  } else {
+    id = ++gLastTouchID & 0x7FFFFFFF;
+  }
+
+  touch =
+      new dom::Touch(id, touchPoint, LayoutDeviceIntPoint(1, 1), 0.0f, 0.0f);
+
+  WidgetTouchEvent event(true, msg, this);
+  KeymapWrapper::InitInputEvent(event, aEvent->state);
+
+  if (msg == eTouchStart || msg == eTouchMove) {
+    mTouches.InsertOrUpdate(aEvent->sequence, std::move(touch));
+    // add all touch points to event object
+    for (const auto& data : mTouches.Values()) {
+      event.mTouches.AppendElement(new dom::Touch(*data));
+    }
+  } else if (msg == eTouchEnd || msg == eTouchCancel) {
+    *event.mTouches.AppendElement() = std::move(touch);
+  }
+
+  nsIWidget::ContentAndAPZEventStatus eventStatus = DispatchInputEvent(&event);
+
+  // There's a chance that we are in drag area and the event is not consumed
+  // by something on it.
+  if (msg == eTouchStart && mDraggableRegion.Contains(touchPoint) &&
+      eventStatus.mApzStatus != nsEventStatus_eConsumeNoDefault) {
+    mWindowShouldStartDragging = true;
+  }
+  return TRUE;
+}
+
+// Return true if toplevel window is transparent.
+// It's transparent when we're running on composited screens
+// and we can draw main window without system titlebar.
+bool nsWindow::IsToplevelWindowTransparent() {
+  static bool transparencyConfigured = false;
+
+  if (!transparencyConfigured) {
+    if (gdk_screen_is_composited(gdk_screen_get_default())) {
+      // Some Gtk+ themes use non-rectangular toplevel windows. To fully
+      // support such themes we need to make toplevel window transparent
+      // with ARGB visual.
+      // It may cause performanance issue so make it configurable
+      // and enable it by default for selected window managers.
+      if (Preferences::HasUserValue("mozilla.widget.use-argb-visuals")) {
+        // argb visual is explicitly required so use it
+        sTransparentMainWindow =
+            Preferences::GetBool("mozilla.widget.use-argb-visuals");
+      } else {
+        // Enable transparent toplevel window if we can draw main window
+        // without system titlebar as Gtk+ themes use titlebar round corners.
+        sTransparentMainWindow =
+            GetSystemGtkWindowDecoration() != GTK_DECORATION_NONE;
+      }
+    }
+    transparencyConfigured = true;
+  }
+
+  return sTransparentMainWindow;
+}
+
+#ifdef MOZ_X11
+// Configure GL visual on X11.
+bool nsWindow::ConfigureX11GLVisual() {
+  auto* screen = gtk_widget_get_screen(mShell);
+  int visualId = 0;
+  bool haveVisual = false;
+
+  if (gfxVars::UseEGL()) {
+    haveVisual = GLContextEGL::FindVisual(&visualId);
+  }
+
+  // We are on GLX or use it as a fallback on Mesa, see
+  // https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
+  if (!haveVisual) {
+    auto* display = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(mShell));
+    int screenNumber = GDK_SCREEN_XNUMBER(screen);
+    haveVisual = GLContextGLX::FindVisual(display, screenNumber, &visualId);
+  }
+
+  GdkVisual* gdkVisual = nullptr;
+  if (haveVisual) {
+    // If we're using CSD, rendering will go through mContainer, but
+    // it will inherit this visual as it is a child of mShell.
+    gdkVisual = gdk_x11_screen_lookup_visual(screen, visualId);
+  }
+  if (!gdkVisual) {
+    NS_WARNING("We're missing X11 Visual!");
+    // We try to use a fallback alpha visual
+    GdkScreen* screen = gtk_widget_get_screen(mShell);
+    gdkVisual = gdk_screen_get_rgba_visual(screen);
+  }
+  if (gdkVisual) {
+    gtk_widget_set_visual(mShell, gdkVisual);
+    mHasAlphaVisual = true;
+    return true;
+  }
+
+  return false;
+}
+#endif
+
+nsAutoCString nsWindow::GetFrameTag() const {
+  if (nsIFrame* frame = GetFrame()) {
+#ifdef DEBUG_FRAME_DUMP
+    return frame->ListTag();
+#else
+    nsAutoCString buf;
+    buf.AppendPrintf("Frame(%p)", frame);
+    if (nsIContent* content = frame->GetContent()) {
+      buf.Append(' ');
+      AppendUTF16toUTF8(content->NodeName(), buf);
+    }
+    return buf;
+#endif
+  }
+  return nsAutoCString("(no frame)");
+}
+
+nsCString nsWindow::GetPopupTypeName() {
+  switch (mPopupHint) {
+    case ePopupTypeMenu:
+      return nsCString("Menu");
+    case ePopupTypeTooltip:
+      return nsCString("Tooltip");
+    case ePopupTypePanel:
+      return nsCString("Panel/Utility");
+    default:
+      return nsCString("Unknown");
+  }
+}
+
+// Disables all rendering of GtkWidget from Gtk side.
+// We do our best to persuade Gtk/Gdk to ignore all painting
+// to the widget.
+static void GtkWidgetDisableUpdates(GtkWidget* aWidget) {
+  // Clear exposure mask - it disabled synthesized events.
+  GdkWindow* window = gtk_widget_get_window(aWidget);
+  gdk_window_set_events(window, (GdkEventMask)(gdk_window_get_events(window) &
+                                               (~GDK_EXPOSURE_MASK)));
+
+  // Remove before/after paint handles from frame clock.
+  // It disables widget content updates.
+  GdkFrameClock* frame_clock = gdk_window_get_frame_clock(window);
+  g_signal_handlers_disconnect_by_data(frame_clock, window);
+}
+
+Window nsWindow::GetX11Window() {
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    return mGdkWindow ? gdk_x11_window_get_xid(mGdkWindow) : X11None;
+  }
+#endif
+  return (Window) nullptr;
+}
+
+void nsWindow::EnsureGdkWindow() {
+  if (!mGdkWindow) {
+    mGdkWindow = gtk_widget_get_window(mDrawToContainer ? GTK_WIDGET(mContainer)
+                                                        : mShell);
+    g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", this);
+  }
+}
+
+bool nsWindow::GetShapedState() {
+  return mIsTransparent && !mHasAlphaVisual && !mTransparencyBitmapForTitlebar;
+}
+
+void nsWindow::ConfigureCompositor() {
+  MOZ_DIAGNOSTIC_ASSERT(mCompositorState == COMPOSITOR_ENABLED);
+  MOZ_DIAGNOSTIC_ASSERT(mIsMapped);
+
+  LOG("nsWindow::ConfigureCompositor()");
+  auto startCompositing = [self = RefPtr{this}, this]() -> void {
+    LOG("  moz_container_wayland_add_or_fire_initial_draw_callback "
+        "ConfigureCompositor");
+
+    // too late
+    if (mIsDestroyed || !mIsMapped) {
+      LOG("  quit, mIsDestroyed = %d mIsMapped = %d", !!mIsDestroyed,
+          mIsMapped);
+      return;
+    }
+    // Compositor will be resumed later by ResumeCompositorFlickering().
+    if (mCompositorState == COMPOSITOR_PAUSED_FLICKERING) {
+      LOG("  quit, will be resumed by ResumeCompositorFlickering.");
+      return;
+    }
+    // Compositor will be resumed at nsWindow::SetCompositorWidgetDelegate().
+    if (!mCompositorWidgetDelegate) {
+      LOG("  quit, missing mCompositorWidgetDelegate");
+      return;
+    }
+
+    ResumeCompositorImpl();
+  };
+
+  if (GdkIsWaylandDisplay()) {
+#ifdef MOZ_WAYLAND
+    moz_container_wayland_add_or_fire_initial_draw_callback(mContainer,
+                                                            startCompositing);
+#endif
+  } else {
+    startCompositing();
+  }
+}
+
+void nsWindow::ConfigureGdkWindow() {
+  LOG("nsWindow::ConfigureGdkWindow()");
+
+  EnsureGdkWindow();
+
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    GdkVisual* gdkVisual = gdk_window_get_visual(mGdkWindow);
+    Visual* visual = gdk_x11_visual_get_xvisual(gdkVisual);
+    int depth = gdk_visual_get_depth(gdkVisual);
+    mSurfaceProvider.Initialize(GetX11Window(), visual, depth,
+                                GetShapedState());
+
+    // Set window manager hint to keep fullscreen windows composited.
+    //
+    // If the window were to get unredirected, there could be visible
+    // tearing because Gecko does not align its framebuffer updates with
+    // vblank.
+    SetCompositorHint(GTK_WIDGET_COMPOSIDED_ENABLED);
+  }
+#endif
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay()) {
+    mSurfaceProvider.Initialize(this);
+  }
+#endif
+
+  if (mIsDragPopup) {
+    if (GdkIsWaylandDisplay()) {
+      // Disable painting to the widget on Wayland as we paint directly to the
+      // widget. Wayland compositors does not paint wl_subsurface
+      // of D&D widget.
+      if (GtkWidget* parent = gtk_widget_get_parent(mShell)) {
+        GtkWidgetDisableUpdates(parent);
+      }
+      GtkWidgetDisableUpdates(mShell);
+      GtkWidgetDisableUpdates(GTK_WIDGET(mContainer));
+    } else {
+      // Disable rendering of parent container on X11 to avoid flickering.
+      if (GtkWidget* parent = gtk_widget_get_parent(mShell)) {
+        gtk_widget_set_opacity(parent, 0.0);
+      }
+    }
+  }
+
+  if (mWindowType == eWindowType_popup) {
+    if (mNoAutoHide) {
+      gint wmd = ConvertBorderStyles(mBorderStyle);
+      if (wmd != -1) {
+        gdk_window_set_decorations(mGdkWindow, (GdkWMDecoration)wmd);
+      }
+    }
+    // If the popup ignores mouse events, set an empty input shape.
+    SetInputRegion(mInputRegion);
+  }
+
+  RefreshWindowClass();
+
+  // We're not mapped yet but we have already created compositor.
+  if (mCompositorWidgetDelegate) {
+    ConfigureCompositor();
+  }
+
+  LOG("  finished, new GdkWindow %p XID 0x%lx\n", mGdkWindow, GetX11Window());
+}
+
+void nsWindow::ReleaseGdkWindow() {
+  LOG("nsWindow::ReleaseGdkWindow()");
+
+  DestroyChildWindows();
+
+  if (mCompositorWidgetDelegate) {
+    mCompositorWidgetDelegate->DisableRendering();
+  }
+
+  if (mGdkWindow) {
+    g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", nullptr);
+    mGdkWindow = nullptr;
+  }
+
+  mSurfaceProvider.CleanupResources();
+}
+
+nsresult nsWindow::Create(nsIWidget* aParent, nsNativeWidget aNativeParent,
+                          const LayoutDeviceIntRect& aRect,
+                          nsWidgetInitData* aInitData) {
+  LOG("nsWindow::Create\n");
+
+  // only set the base parent if we're going to be a dialog or a
+  // toplevel
+  nsIWidget* baseParent =
+      aInitData && (aInitData->mWindowType == eWindowType_dialog ||
+                    aInitData->mWindowType == eWindowType_toplevel ||
+                    aInitData->mWindowType == eWindowType_invisible)
+          ? nullptr
+          : aParent;
+
+#ifdef ACCESSIBILITY
+  // Send a DBus message to check whether a11y is enabled
+  a11y::PreInit();
+#endif
+
+#ifdef MOZ_WAYLAND
+  // Ensure that KeymapWrapper is created on Wayland as we need it for
+  // keyboard focus tracking.
+  if (GdkIsWaylandDisplay()) {
+    KeymapWrapper::EnsureInstance();
+  }
+#endif
+
+  // Ensure that the toolkit is created.
+  nsGTKToolkit::GetToolkit();
+
+  // initialize all the common bits of this class
+  BaseCreate(baseParent, aInitData);
+
+  // and do our common creation
+  mParent = aParent;
+  mCreated = true;
+  // save our bounds
+  mBounds = aRect;
+  LOG("  mBounds: x:%d y:%d w:%d h:%d\n", mBounds.x, mBounds.y, mBounds.width,
+      mBounds.height);
+
+  ConstrainSize(&mBounds.width, &mBounds.height);
+  mLastSizeRequest = mBounds.Size();
+
+  GtkWidget* eventWidget = nullptr;
+  bool popupNeedsAlphaVisual = (mWindowType == eWindowType_popup &&
+                                (aInitData && aInitData->mSupportTranslucency));
+
+  // Figure out our parent window - only used for eWindowType_child
+  GdkWindow* parentGdkWindow = nullptr;
+  nsWindow* parentnsWindow = nullptr;
+
+  if (aParent) {
+    parentnsWindow = static_cast<nsWindow*>(aParent);
+    parentGdkWindow = parentnsWindow->mGdkWindow;
+  } else if (aNativeParent && GDK_IS_WINDOW(aNativeParent)) {
+    parentGdkWindow = GDK_WINDOW(aNativeParent);
+    parentnsWindow = get_window_for_gdk_window(parentGdkWindow);
+    if (!parentnsWindow) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  if (mWindowType == eWindowType_child) {
+    // We don't support eWindowType_child directly but emulate it by popup
+    // windows.
+    mWindowType = eWindowType_popup;
+    if (!parentnsWindow) {
+      if (aNativeParent && GTK_IS_CONTAINER(aNativeParent)) {
+        parentnsWindow = get_window_for_gtk_widget(GTK_WIDGET(aNativeParent));
+      }
+    }
+    mIsChildWindow = true;
+    LOG("  child widget, switch to popup. parent nsWindow %p", parentnsWindow);
+  }
+
+  if (mWindowType == eWindowType_popup && !parentnsWindow) {
+    LOG("  popup window without parent!");
+    if (GdkIsWaylandDisplay()) {
+      LOG("  switch to toplevel on Wayland.");
+      // Wayland does not allow to create popup without parent so switch to
+      // toplevel and mark as wayland panel.
+      mIsWaylandPanelWindow = true;
+      mWindowType = eWindowType_toplevel;
+    }
+  }
+
+  if (mWindowType != eWindowType_dialog && mWindowType != eWindowType_popup &&
+      mWindowType != eWindowType_toplevel &&
+      mWindowType != eWindowType_invisible) {
+    MOZ_ASSERT_UNREACHABLE("Unexpected eWindowType");
+    return NS_ERROR_FAILURE;
+  }
+
+  mAlwaysOnTop = aInitData && aInitData->mAlwaysOnTop;
+  mIsPIPWindow = aInitData && aInitData->mPIPWindow;
+  // mNoAutoHide seems to be always false here.
+  // The mNoAutoHide state is set later on nsMenuPopupFrame level
+  // and can be changed so we use WaylandPopupIsPermanent() to get
+  // recent popup config (Bug 1728952).
+  mNoAutoHide = aInitData && aInitData->mNoAutoHide;
+
+  // Popups that are not noautohide are only temporary. The are used
+  // for menus and the like and disappear when another window is used.
+  // For most popups, use the standard GtkWindowType GTK_WINDOW_POPUP,
+  // which will use a Window with the override-redirect attribute
+  // (for temporary windows).
+  // For long-lived windows, their stacking order is managed by the
+  // window manager, as indicated by GTK_WINDOW_TOPLEVEL.
+  // For Wayland we have to always use GTK_WINDOW_POPUP to control
+  // popup window position.
+  GtkWindowType type = GTK_WINDOW_TOPLEVEL;
+  if (mWindowType == eWindowType_popup) {
+    MOZ_ASSERT(aInitData);
+    type = GTK_WINDOW_POPUP;
+    if (GdkIsX11Display() && mNoAutoHide) {
+      type = GTK_WINDOW_TOPLEVEL;
+    }
+  }
+  mShell = gtk_window_new(type);
+
+  // Ensure gfxPlatform is initialized, since that is what initializes
+  // gfxVars, used below.
+  Unused << gfxPlatform::GetPlatform();
+
+  if (mWindowType == eWindowType_toplevel ||
+      mWindowType == eWindowType_dialog) {
+    mGtkWindowDecoration = GetSystemGtkWindowDecoration();
+  }
+
+  // Don't use transparency for PictureInPicture windows.
+  bool toplevelNeedsAlphaVisual = false;
+  if (mWindowType == eWindowType_toplevel && !mIsPIPWindow) {
+    toplevelNeedsAlphaVisual = IsToplevelWindowTransparent();
+  }
+
+  bool isGLVisualSet = false;
+  mIsAccelerated = ComputeShouldAccelerate();
+#ifdef MOZ_X11
+  if (GdkIsX11Display() && mIsAccelerated) {
+    isGLVisualSet = ConfigureX11GLVisual();
+  }
+#endif
+  if (!isGLVisualSet && (popupNeedsAlphaVisual || toplevelNeedsAlphaVisual)) {
+    // We're running on composited screen so we can use alpha visual
+    // for both toplevel and popups.
+    if (mCompositedScreen) {
+      GdkVisual* visual =
+          gdk_screen_get_rgba_visual(gtk_widget_get_screen(mShell));
+      if (visual) {
+        gtk_widget_set_visual(mShell, visual);
+        mHasAlphaVisual = true;
+      }
+    }
+  }
+
+  // Use X shape mask to draw round corners of Firefox titlebar.
+  // We don't use shape masks any more as we switched to ARGB visual
+  // by default and non-compositing screens use solid-csd decorations
+  // without round corners.
+  // Leave the shape mask code here as it can be used to draw round
+  // corners on EGL (https://gitlab.freedesktop.org/mesa/mesa/-/issues/149)
+  // or when custom titlebar theme is used.
+  mTransparencyBitmapForTitlebar = TitlebarUseShapeMask();
+
+  // We have a toplevel window with transparency.
+  // Calls to UpdateTitlebarTransparencyBitmap() from OnExposeEvent()
+  // occur before SetTransparencyMode() receives eTransparencyTransparent
+  // from layout, so set mIsTransparent here.
+  if (mWindowType == eWindowType_toplevel &&
+      (mHasAlphaVisual || mTransparencyBitmapForTitlebar)) {
+    mIsTransparent = true;
+  }
+
+  // We only move a general managed toplevel window if someone has
+  // actually placed the window somewhere.  If no placement has taken
+  // place, we just let the window manager Do The Right Thing.
+  if (AreBoundsSane()) {
+    GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mBounds.Size());
+    LOG("nsWindow::Create() Initial resize to %d x %d\n", size.width,
+        size.height);
+    gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
+  }
+
+  if (mWindowType == eWindowType_dialog) {
+    mGtkWindowRoleName = "Dialog";
+
+    SetDefaultIcon();
+    gtk_window_set_type_hint(GTK_WINDOW(mShell), GDK_WINDOW_TYPE_HINT_DIALOG);
+    LOG("nsWindow::Create(): dialog");
+    if (parentnsWindow) {
+      GtkWindowSetTransientFor(GTK_WINDOW(mShell),
+                               GTK_WINDOW(parentnsWindow->GetGtkWidget()));
+      LOG("    set parent window [%p]\n", parentnsWindow);
+    }
+  } else if (mWindowType == eWindowType_popup) {
+    MOZ_ASSERT(aInitData);
+    mGtkWindowRoleName = "Popup";
+    mPopupHint = aInitData->mPopupHint;
+
+    LOG("nsWindow::Create() Popup");
+
+    if (mNoAutoHide) {
+      // ... but the window manager does not decorate this window,
+      // nor provide a separate taskbar icon.
+      if (mBorderStyle == eBorderStyle_default) {
+        gtk_window_set_decorated(GTK_WINDOW(mShell), FALSE);
+      } else {
+        bool decorate = mBorderStyle & eBorderStyle_title;
+        gtk_window_set_decorated(GTK_WINDOW(mShell), decorate);
+        if (decorate) {
+          gtk_window_set_deletable(GTK_WINDOW(mShell),
+                                   mBorderStyle & eBorderStyle_close);
+        }
+      }
+      gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mShell), TRUE);
+      // Element focus is managed by the parent window so the
+      // WM_HINTS input field is set to False to tell the window
+      // manager not to set input focus to this window ...
+      gtk_window_set_accept_focus(GTK_WINDOW(mShell), FALSE);
+#ifdef MOZ_X11
+      // ... but when the window manager offers focus through
+      // WM_TAKE_FOCUS, focus is requested on the parent window.
+      if (GdkIsX11Display()) {
+        gtk_widget_realize(mShell);
+        gdk_window_add_filter(gtk_widget_get_window(mShell),
+                              popup_take_focus_filter, nullptr);
+      }
+#endif
+    }
+
+    if (aInitData->mIsDragPopup) {
+      gtk_window_set_type_hint(GTK_WINDOW(mShell), GDK_WINDOW_TYPE_HINT_DND);
+      mIsDragPopup = true;
+      LOG("nsWindow::Create() Drag popup\n");
+    } else if (GdkIsX11Display()) {
+      // Set the window hints on X11 only. Wayland popups are configured
+      // at WaylandPopupConfigure().
+      GdkWindowTypeHint gtkTypeHint;
+      switch (mPopupHint) {
+        case ePopupTypeMenu:
+          gtkTypeHint = GDK_WINDOW_TYPE_HINT_POPUP_MENU;
+          break;
+        case ePopupTypeTooltip:
+          gtkTypeHint = GDK_WINDOW_TYPE_HINT_TOOLTIP;
+          break;
+        default:
+          gtkTypeHint = GDK_WINDOW_TYPE_HINT_UTILITY;
+          break;
+      }
+      gtk_window_set_type_hint(GTK_WINDOW(mShell), gtkTypeHint);
+      LOG("nsWindow::Create() popup type %s", GetPopupTypeName().get());
+    }
+    if (parentnsWindow) {
+      LOG("    set parent window [%p] %s", parentnsWindow,
+          parentnsWindow->mGtkWindowRoleName.get());
+      GtkWindow* parentWidget = GTK_WINDOW(parentnsWindow->GetGtkWidget());
+      GtkWindowSetTransientFor(GTK_WINDOW(mShell), parentWidget);
+
+      // If popup parent is modal, we need to make popup modal on Wayland too.
+      if (GdkIsWaylandDisplay() && mPopupHint != ePopupTypeTooltip &&
+          gtk_window_get_modal(parentWidget)) {
+        gtk_window_set_modal(GTK_WINDOW(mShell), true);
+      }
+    }
+
+    // We need realized mShell at NativeMoveResize().
+    gtk_widget_realize(mShell);
+
+    // With popup windows, we want to set their position.
+    // Place them immediately on X11 and save initial popup position
+    // on Wayland as we place Wayland popup on show.
+    if (GdkIsX11Display()) {
+      NativeMoveResize(/* move */ true, /* resize */ false);
+    } else if (AreBoundsSane()) {
+      GdkRectangle rect = DevicePixelsToGdkRectRoundOut(mBounds);
+      mPopupPosition = {rect.x, rect.y};
+    }
+  } else {  // must be eWindowType_toplevel
+    mGtkWindowRoleName = "Toplevel";
+    SetDefaultIcon();
+
+    LOG("nsWindow::Create() Toplevel\n");
+
+    if (mIsPIPWindow) {
+      LOG("    Is PIP Window\n");
+      gtk_window_set_type_hint(GTK_WINDOW(mShell),
+                               GDK_WINDOW_TYPE_HINT_UTILITY);
+    }
+
+    // each toplevel window gets its own window group
+    GtkWindowGroup* group = gtk_window_group_new();
+    gtk_window_group_add_window(group, GTK_WINDOW(mShell));
+    g_object_unref(group);
+  }
+
+  if (mAlwaysOnTop) {
+    gtk_window_set_keep_above(GTK_WINDOW(mShell), TRUE);
+  }
+
+  // Create a container to hold child windows and child GtkWidgets.
+  GtkWidget* container = moz_container_new();
+  mContainer = MOZ_CONTAINER(container);
+
+  // "csd" style is set when widget is realized so we need to call
+  // it explicitly now.
+  gtk_widget_realize(mShell);
+
+  /* There are several cases here:
+   *
+   * 1) We're running on Gtk+ without client side decorations.
+   *    Content is rendered to mShell window and we listen
+   *    to the Gtk+ events on mShell
+   * 2) We're running on Gtk+ and client side decorations
+   *    are drawn by Gtk+ to mShell. Content is rendered to mContainer
+   *    and we listen to the Gtk+ events on mContainer.
+   * 3) We're running on Wayland. All gecko content is rendered
+   *    to mContainer and we listen to the Gtk+ events on mContainer.
+   */
+  GtkStyleContext* style = gtk_widget_get_style_context(mShell);
+  mDrawToContainer = GdkIsWaylandDisplay() ||
+                     mGtkWindowDecoration == GTK_DECORATION_CLIENT ||
+                     gtk_style_context_has_class(style, "csd");
+  eventWidget = mDrawToContainer ? container : mShell;
+
+  // Prevent GtkWindow from painting a background to avoid flickering.
+  gtk_widget_set_app_paintable(
+      eventWidget, StaticPrefs::widget_transparent_windows_AtStartup());
+
+  gtk_widget_add_events(eventWidget, kEvents);
+
+  if (mDrawToContainer) {
+    gtk_widget_add_events(mShell, GDK_PROPERTY_CHANGE_MASK);
+    gtk_widget_set_app_paintable(
+        mShell, StaticPrefs::widget_transparent_windows_AtStartup());
+  }
+  if (mTransparencyBitmapForTitlebar) {
+    moz_container_force_default_visual(mContainer);
+  }
+
+  // If we draw to mContainer window then configure it now because
+  // gtk_container_add() realizes the child widget.
+  gtk_widget_set_has_window(container, mDrawToContainer);
+
+  gtk_container_add(GTK_CONTAINER(mShell), container);
+
+  // alwaysontop windows are generally used for peripheral indicators,
+  // so we don't focus them by default.
+  if (mAlwaysOnTop) {
+    gtk_window_set_focus_on_map(GTK_WINDOW(mShell), FALSE);
+  }
+
+  gtk_widget_realize(container);
+
+  // make sure this is the focus widget in the container
+  gtk_widget_show(container);
+
+  if (!mAlwaysOnTop) {
+    gtk_widget_grab_focus(container);
+  }
+
+  if (mIsWaylandPanelWindow) {
+    gtk_window_set_decorated(GTK_WINDOW(mShell), false);
+  }
+
+#ifdef MOZ_WAYLAND
+  if (mIsDragPopup && GdkIsWaylandDisplay()) {
+    LOG("  set commit to parent");
+    moz_container_wayland_set_commit_to_parent(mContainer);
+  }
+#endif
+
+  if (mWindowType == eWindowType_popup) {
+    MOZ_ASSERT(aInitData);
+    // gdk does not automatically set the cursor for "temporary"
+    // windows, which are what gtk uses for popups.
+
+    // force SetCursor to actually set the cursor, even though our internal
+    // state indicates that we already have the standard cursor.
+    mUpdateCursor = true;
+    SetCursor(Cursor{eCursor_standard});
+  }
+
+  if (mIsChildWindow && parentnsWindow) {
+    GdkWindow* window = GetToplevelGdkWindow();
+    GdkWindow* parentWindow = parentnsWindow->GetToplevelGdkWindow();
+    LOG("  child GdkWindow %p set parent GdkWindow %p", window, parentWindow);
+    gdk_window_reparent(window, parentWindow,
+                        DevicePixelsToGdkCoordRoundDown(mBounds.x),
+                        DevicePixelsToGdkCoordRoundDown(mBounds.y));
+  }
+
+  if (mDrawToContainer) {
+    // Also label mShell toplevel window,
+    // property_notify_event_cb callback also needs to find its way home
+    g_object_set_data(G_OBJECT(gtk_widget_get_window(mShell)), "nsWindow",
+                      this);
+  }
+
+  g_object_set_data(G_OBJECT(mContainer), "nsWindow", this);
+  g_object_set_data(G_OBJECT(mShell), "nsWindow", this);
+
+  // attach listeners for events
+  g_signal_connect(mShell, "configure_event", G_CALLBACK(configure_event_cb),
+                   nullptr);
+  g_signal_connect(mShell, "delete_event", G_CALLBACK(delete_event_cb),
+                   nullptr);
+  g_signal_connect(mShell, "window_state_event",
+                   G_CALLBACK(window_state_event_cb), nullptr);
+  g_signal_connect(mShell, "check-resize", G_CALLBACK(check_resize_cb),
+                   nullptr);
+  g_signal_connect(mShell, "composited-changed",
+                   G_CALLBACK(widget_composited_changed_cb), nullptr);
+  g_signal_connect(mShell, "property-notify-event",
+                   G_CALLBACK(property_notify_event_cb), nullptr);
+
+  if (mWindowType == eWindowType_toplevel) {
+    g_signal_connect_after(mShell, "size_allocate",
+                           G_CALLBACK(toplevel_window_size_allocate_cb),
+                           nullptr);
+  }
+
+  GdkScreen* screen = gtk_widget_get_screen(mShell);
+  if (!g_signal_handler_find(screen, G_SIGNAL_MATCH_FUNC, 0, 0, nullptr,
+                             FuncToGpointer(screen_composited_changed_cb),
+                             nullptr)) {
+    g_signal_connect(screen, "composited-changed",
+                     G_CALLBACK(screen_composited_changed_cb), nullptr);
+  }
+
+  gtk_drag_dest_set((GtkWidget*)mShell, (GtkDestDefaults)0, nullptr, 0,
+                    (GdkDragAction)0);
+  g_signal_connect(mShell, "drag_motion", G_CALLBACK(drag_motion_event_cb),
+                   nullptr);
+  g_signal_connect(mShell, "drag_leave", G_CALLBACK(drag_leave_event_cb),
+                   nullptr);
+  g_signal_connect(mShell, "drag_drop", G_CALLBACK(drag_drop_event_cb),
+                   nullptr);
+  g_signal_connect(mShell, "drag_data_received",
+                   G_CALLBACK(drag_data_received_event_cb), nullptr);
+
+  GtkSettings* default_settings = gtk_settings_get_default();
+  g_signal_connect_after(default_settings, "notify::gtk-xft-dpi",
+                         G_CALLBACK(settings_xft_dpi_changed_cb), this);
+
+  // Widget signals
+  g_signal_connect(mContainer, "map", G_CALLBACK(widget_map_cb), nullptr);
+  g_signal_connect(mContainer, "unmap", G_CALLBACK(widget_unmap_cb), nullptr);
+  g_signal_connect(mContainer, "unrealize", G_CALLBACK(widget_unrealize_cb),
+                   nullptr);
+  g_signal_connect_after(mContainer, "size_allocate",
+                         G_CALLBACK(size_allocate_cb), nullptr);
+  g_signal_connect(mContainer, "hierarchy-changed",
+                   G_CALLBACK(hierarchy_changed_cb), nullptr);
+  g_signal_connect(mContainer, "notify::scale-factor",
+                   G_CALLBACK(scale_changed_cb), nullptr);
+  // Initialize mHasMappedToplevel.
+  hierarchy_changed_cb(GTK_WIDGET(mContainer), nullptr);
+  // Expose, focus, key, and drag events are sent even to GTK_NO_WINDOW
+  // widgets.
+  g_signal_connect(G_OBJECT(mContainer), "draw", G_CALLBACK(expose_event_cb),
+                   nullptr);
+  g_signal_connect(mContainer, "focus_in_event", G_CALLBACK(focus_in_event_cb),
+                   nullptr);
+  g_signal_connect(mContainer, "focus_out_event",
+                   G_CALLBACK(focus_out_event_cb), nullptr);
+  g_signal_connect(mContainer, "key_press_event",
+                   G_CALLBACK(key_press_event_cb), nullptr);
+  g_signal_connect(mContainer, "key_release_event",
+                   G_CALLBACK(key_release_event_cb), nullptr);
+
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    GtkWidget* widgets[] = {GTK_WIDGET(mContainer),
+                            !mDrawToContainer ? mShell : nullptr};
+    for (size_t i = 0; i < ArrayLength(widgets) && widgets[i]; ++i) {
+      // Double buffering is controlled by the window's owning
+      // widget. Disable double buffering for painting directly to the
+      // X Window.
+      gtk_widget_set_double_buffered(widgets[i], FALSE);
+    }
+  }
+#endif
+#ifdef MOZ_WAYLAND
+  // Initialize the window specific VsyncSource early in order to avoid races
+  // with BrowserParent::UpdateVsyncParentVsyncDispatcher().
+  // Only use for toplevel windows for now, see bug 1619246.
+  if (GdkIsWaylandDisplay() &&
+      StaticPrefs::widget_wayland_vsync_enabled_AtStartup() &&
+      mWindowType == eWindowType_toplevel) {
+    mWaylandVsyncSource = new WaylandVsyncSource(this);
+    mWaylandVsyncDispatcher = new VsyncDispatcher(mWaylandVsyncSource);
+    LOG_VSYNC("  created WaylandVsyncSource)");
+    MOZ_RELEASE_ASSERT(mWaylandVsyncSource);
+  }
+#endif
+
+  // We create input contexts for all containers, except for
+  // toplevel popup windows
+  if (mWindowType != eWindowType_popup) {
+    mIMContext = new IMContextWrapper(this);
+  }
+
+  // These events are sent to the owning widget of the relevant window
+  // and propagate up to the first widget that handles the events, so we
+  // need only connect on mShell, if it exists, to catch events on its
+  // window and windows of mContainer.
+  g_signal_connect(eventWidget, "enter-notify-event",
+                   G_CALLBACK(enter_notify_event_cb), nullptr);
+  g_signal_connect(eventWidget, "leave-notify-event",
+                   G_CALLBACK(leave_notify_event_cb), nullptr);
+  g_signal_connect(eventWidget, "motion-notify-event",
+                   G_CALLBACK(motion_notify_event_cb), nullptr);
+  g_signal_connect(eventWidget, "button-press-event",
+                   G_CALLBACK(button_press_event_cb), nullptr);
+  g_signal_connect(eventWidget, "button-release-event",
+                   G_CALLBACK(button_release_event_cb), nullptr);
+  g_signal_connect(eventWidget, "scroll-event", G_CALLBACK(scroll_event_cb),
+                   nullptr);
+  if (gtk_check_version(3, 18, 0) == nullptr) {
+    g_signal_connect(eventWidget, "event", G_CALLBACK(generic_event_cb),
+                     nullptr);
+  }
+  g_signal_connect(eventWidget, "touch-event", G_CALLBACK(touch_event_cb),
+                   nullptr);
+
+  LOG("  nsWindow type %d %s\n", mWindowType, mIsPIPWindow ? "PIP window" : "");
+  LOG("  mShell %p mContainer %p mGdkWindow %p XID 0x%lx\n", mShell, mContainer,
+      mGdkWindow, GetX11Window());
+
+  // Set default application name when it's empty.
+  if (mGtkWindowAppName.IsEmpty()) {
+    mGtkWindowAppName = gAppData->name;
+  }
+
+  return NS_OK;
+}
+
+void nsWindow::RefreshWindowClass(void) {
+  GdkWindow* gdkWindow = gtk_widget_get_window(mShell);
+  if (!gdkWindow) {
+    return;
+  }
+
+  if (!mGtkWindowRoleName.IsEmpty()) {
+    gdk_window_set_role(gdkWindow, mGtkWindowRoleName.get());
+  }
+
+#ifdef MOZ_X11
+  if (!mGtkWindowAppName.IsEmpty() && GdkIsX11Display()) {
+    XClassHint* class_hint = XAllocClassHint();
+    if (!class_hint) {
+      return;
+    }
+    const char* res_class = gdk_get_program_class();
+    if (!res_class) return;
+
+    class_hint->res_name = const_cast<char*>(mGtkWindowAppName.get());
+    class_hint->res_class = const_cast<char*>(res_class);
+
+    // Can't use gtk_window_set_wmclass() for this; it prints
+    // a warning & refuses to make the change.
+    GdkDisplay* display = gdk_display_get_default();
+    XSetClassHint(GDK_DISPLAY_XDISPLAY(display),
+                  gdk_x11_window_get_xid(gdkWindow), class_hint);
+    XFree(class_hint);
+  }
+#endif /* MOZ_X11 */
+}
+
+void nsWindow::SetWindowClass(const nsAString& xulWinType) {
+  if (!mShell) return;
+
+  char* res_name = ToNewCString(xulWinType, mozilla::fallible);
+  if (!res_name) return;
+
+  const char* role = nullptr;
+
+  // Parse res_name into a name and role. Characters other than
+  // [A-Za-z0-9_-] are converted to '_'. Anything after the first
+  // colon is assigned to role; if there's no colon, assign the
+  // whole thing to both role and res_name.
+  for (char* c = res_name; *c; c++) {
+    if (':' == *c) {
+      *c = 0;
+      role = c + 1;
+    } else if (!isascii(*c) || (!isalnum(*c) && ('_' != *c) && ('-' != *c))) {
+      *c = '_';
+    }
+  }
+  res_name[0] = (char)toupper(res_name[0]);
+  if (!role) role = res_name;
+
+  mGtkWindowAppName = res_name;
+  mGtkWindowRoleName = role;
+  free(res_name);
+
+  RefreshWindowClass();
+}
+
+nsAutoCString nsWindow::GetDebugTag() const {
+  nsAutoCString tag;
+  tag.AppendPrintf("[%p]", this);
+  return tag;
+}
+
+void nsWindow::NativeMoveResize(bool aMoved, bool aResized) {
+  GdkPoint topLeft = DevicePixelsToGdkPointRoundDown(mBounds.TopLeft());
+  GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mLastSizeRequest);
+
+  LOG("nsWindow::NativeMoveResize move %d resize %d to %d,%d -> %d x %d\n",
+      aMoved, aResized, topLeft.x, topLeft.y, size.width, size.height);
+
+  if (aResized && !AreBoundsSane()) {
+    LOG("  bounds are insane, hidding the window");
+    // We have been resized but to incorrect size.
+    // If someone has set this so that the needs show flag is false
+    // and it needs to be hidden, update the flag and hide the
+    // window.  This flag will be cleared the next time someone
+    // hides the window or shows it.  It also prevents us from
+    // calling NativeShow(false) excessively on the window which
+    // causes unneeded X traffic.
+    if (!mNeedsShow && mIsShown) {
+      mNeedsShow = true;
+      NativeShow(false);
+    }
+    if (aMoved) {
+      LOG("  moving to %d x %d", topLeft.x, topLeft.y);
+      gtk_window_move(GTK_WINDOW(mShell), topLeft.x, topLeft.y);
+    }
+    return;
+  }
+
+  // Set position to hidden window on X11 may fail, so save the position
+  // and move it when it's shown.
+  if (aMoved && GdkIsX11Display() && IsPopup() &&
+      !gtk_widget_get_visible(GTK_WIDGET(mShell))) {
+    LOG("  store position of hidden popup window");
+    mHiddenPopupPositioned = true;
+    mPopupPosition = {topLeft.x, topLeft.y};
+  }
+
+  if (IsWaylandPopup()) {
+    NativeMoveResizeWaylandPopup(aMoved, aResized);
+  } else {
+    // x and y give the position of the window manager frame top-left.
+    if (aMoved) {
+      gtk_window_move(GTK_WINDOW(mShell), topLeft.x, topLeft.y);
+    }
+    if (aResized) {
+      gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
+      if (mIsDragPopup) {
+        // DND window is placed inside container so we need to make hard size
+        // request to ensure parent container is resized too.
+        gtk_widget_set_size_request(GTK_WIDGET(mShell), size.width,
+                                    size.height);
+      }
+    }
+  }
+
+  if (aResized) {
+    // Recompute the input region, in case the window grew or shrunk.
+    SetInputRegion(mInputRegion);
+  }
+
+  // Does it need to be shown because bounds were previously insane?
+  if (mNeedsShow && mIsShown && aResized) {
+    NativeShow(true);
+  }
+}
+
+// We pause compositor to avoid rendering of obsoleted remote content which
+// produces flickering.
+// Re-enable compositor again when remote content is updated or
+// timeout happens.
+
+// Define maximal compositor pause when it's paused to avoid flickering,
+// in milliseconds.
+#define COMPOSITOR_PAUSE_TIMEOUT (1000)
+
+void nsWindow::PauseCompositorFlickering() {
+  bool pauseCompositor = (mWindowType == eWindowType_toplevel) &&
+                         mCompositorState == COMPOSITOR_ENABLED &&
+                         mCompositorWidgetDelegate && !mIsDestroyed;
+  if (!pauseCompositor) {
+    return;
+  }
+
+  LOG("nsWindow::PauseCompositorFlickering()");
+
+  MozClearHandleID(mCompositorPauseTimeoutID, g_source_remove);
+
+  CompositorBridgeChild* remoteRenderer = GetRemoteRenderer();
+  if (remoteRenderer) {
+    remoteRenderer->SendPause();
+    mCompositorState = COMPOSITOR_PAUSED_FLICKERING;
+    mCompositorPauseTimeoutID = (int)g_timeout_add(
+        COMPOSITOR_PAUSE_TIMEOUT,
+        [](void* data) -> gint {
+          nsWindow* window = static_cast<nsWindow*>(data);
+          if (!window->IsDestroyed()) {
+            window->ResumeCompositorFlickering();
+          }
+          return true;
+        },
+        this);
+  }
+}
+
+bool nsWindow::IsWaitingForCompositorResume() {
+  return mCompositorState == COMPOSITOR_PAUSED_FLICKERING;
+}
+
+void nsWindow::ResumeCompositorFlickering() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  LOG("nsWindow::ResumeCompositorFlickering()\n");
+
+  if (mIsDestroyed || !IsWaitingForCompositorResume()) {
+    LOG("  early quit\n");
+    return;
+  }
+
+  MozClearHandleID(mCompositorPauseTimeoutID, g_source_remove);
+
+  ResumeCompositorImpl();
+}
+
+void nsWindow::ResumeCompositorFromCompositorThread() {
+  nsCOMPtr<nsIRunnable> event =
+      NewRunnableMethod("nsWindow::ResumeCompositorFlickering", this,
+                        &nsWindow::ResumeCompositorFlickering);
+  NS_DispatchToMainThread(event.forget());
+}
+
+void nsWindow::ResumeCompositorImpl() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  LOG("nsWindow::ResumeCompositorImpl()\n");
+
+  MOZ_DIAGNOSTIC_ASSERT(mCompositorWidgetDelegate);
+  mCompositorWidgetDelegate->EnableRendering(GetX11Window(), GetShapedState());
+
+  // As WaylandStartVsync needs mCompositorWidgetDelegate this is the right
+  // time to start it.
+  WaylandStartVsync();
+
+  CompositorBridgeChild* remoteRenderer = GetRemoteRenderer();
+  MOZ_RELEASE_ASSERT(remoteRenderer);
+  remoteRenderer->SendResume();
+  remoteRenderer->SendForcePresent(wr::RenderReasons::WIDGET);
+  mCompositorState = COMPOSITOR_ENABLED;
+}
+
+void nsWindow::WaylandStartVsync() {
+#ifdef MOZ_WAYLAND
+  if (!mWaylandVsyncSource) {
+    return;
+  }
+
+  LOG_VSYNC("nsWindow::WaylandStartVsync");
+
+  MOZ_DIAGNOSTIC_ASSERT(mCompositorWidgetDelegate);
+  if (mCompositorWidgetDelegate->AsGtkCompositorWidget() &&
+      mCompositorWidgetDelegate->AsGtkCompositorWidget()
+          ->GetNativeLayerRoot()) {
+    LOG_VSYNC("  use source NativeLayerRootWayland");
+    mWaylandVsyncSource->MaybeUpdateSource(
+        mCompositorWidgetDelegate->AsGtkCompositorWidget()
+            ->GetNativeLayerRoot()
+            ->AsNativeLayerRootWayland());
+  } else {
+    LOG_VSYNC("  use source mContainer");
+    mWaylandVsyncSource->MaybeUpdateSource(mContainer);
+  }
+
+  mWaylandVsyncSource->EnableMonitor();
+#endif
+}
+
+void nsWindow::WaylandStopVsync() {
+#ifdef MOZ_WAYLAND
+  if (!mWaylandVsyncSource) {
+    return;
+  }
+
+  LOG_VSYNC("nsWindow::WaylandStopVsync");
+
+  // The widget is going to be hidden, so clear the surface of our
+  // vsync source.
+  mWaylandVsyncSource->DisableMonitor();
+  mWaylandVsyncSource->MaybeUpdateSource(nullptr);
+#endif
+}
+
+void nsWindow::NativeShow(bool aAction) {
+  if (aAction) {
+    // unset our flag now that our window has been shown
+    mNeedsShow = true;
+    auto removeShow = MakeScopeExit([&] { mNeedsShow = false; });
+
+    LOG("nsWindow::NativeShow show\n");
+
+    if (IsWaylandPopup()) {
+      mPopupClosed = false;
+      if (WaylandPopupConfigure()) {
+        AddWindowToPopupHierarchy();
+        UpdateWaylandPopupHierarchy();
+        if (mPopupClosed) {
+          return;
+        }
+      }
+    }
+    // Set up usertime/startupID metadata for the created window.
+    // On X11 we use gtk_window_set_startup_id() so we need to call it
+    // before show.
+    if (GdkIsX11Display()) {
+      SetUserTimeAndStartupTokenForActivatedWindow();
+    }
+    if (GdkIsWaylandDisplay()) {
+      if (IsWaylandPopup()) {
+        ShowWaylandPopupWindow();
+      } else {
+        ShowWaylandToplevelWindow();
+      }
+    } else {
+      LOG("  calling gtk_widget_show(mShell)\n");
+      gtk_widget_show(mShell);
+    }
+    if (GdkIsWaylandDisplay()) {
+      SetUserTimeAndStartupTokenForActivatedWindow();
+#ifdef MOZ_WAYLAND
+      auto token = std::move(mWindowActivationTokenFromEnv);
+      if (!token.IsEmpty()) {
+        FocusWaylandWindow(token.get());
+      }
+#endif
+    }
+    if (mHiddenPopupPositioned && IsPopup()) {
+      LOG("  re-position hidden popup window");
+      gtk_window_move(GTK_WINDOW(mShell), mPopupPosition.x, mPopupPosition.y);
+      mHiddenPopupPositioned = false;
+    }
+  } else {
+    LOG("nsWindow::NativeShow hide\n");
+    if (GdkIsWaylandDisplay()) {
+      if (IsWaylandPopup()) {
+        // We can't close tracked popups directly as they may have visible
+        // child popups. Just mark is as closed and let
+        // UpdateWaylandPopupHierarchy() do the job.
+        if (IsInPopupHierarchy()) {
+          WaylandPopupMarkAsClosed();
+          UpdateWaylandPopupHierarchy();
+        } else {
+          // Close untracked popups directly.
+          HideWaylandPopupWindow(/* aTemporaryHide */ false,
+                                 /* aRemoveFromPopupList */ true);
+        }
+      } else {
+        HideWaylandToplevelWindow();
+      }
+    } else {
+      // Workaround window freezes on GTK versions before 3.21.2 by
+      // ensuring that configure events get dispatched to windows before
+      // they are unmapped. See bug 1225044.
+      if (gtk_check_version(3, 21, 2) != nullptr && mPendingConfigures > 0) {
+        GtkAllocation allocation;
+        gtk_widget_get_allocation(GTK_WIDGET(mShell), &allocation);
+
+        GdkEventConfigure event;
+        PodZero(&event);
+        event.type = GDK_CONFIGURE;
+        event.window = mGdkWindow;
+        event.send_event = TRUE;
+        event.x = allocation.x;
+        event.y = allocation.y;
+        event.width = allocation.width;
+        event.height = allocation.height;
+
+        auto* shellClass = GTK_WIDGET_GET_CLASS(mShell);
+        for (unsigned int i = 0; i < mPendingConfigures; i++) {
+          Unused << shellClass->configure_event(mShell, &event);
+        }
+        mPendingConfigures = 0;
+      }
+      gtk_widget_hide(mShell);
+
+      ClearTransparencyBitmap();  // Release some resources
+    }
+  }
+}
+
+void nsWindow::SetHasMappedToplevel(bool aState) {
+  LOG("nsWindow::SetHasMappedToplevel(%d)", aState);
+  if (aState == mHasMappedToplevel) {
+    return;
+  }
+  // Even when aState == mHasMappedToplevel (as when this method is called
+  // from Show()), child windows need to have their state checked, so don't
+  // return early.
+  mHasMappedToplevel = aState;
+  if (aState && mNeedsToRetryCapturingMouse) {
+    CaptureRollupEvents(true);
+    MOZ_ASSERT(!mNeedsToRetryCapturingMouse);
+  }
+}
+
+LayoutDeviceIntSize nsWindow::GetSafeWindowSize(LayoutDeviceIntSize aSize) {
+  // The X protocol uses CARD32 for window sizes, but the server (1.11.3)
+  // 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 (mWindowRenderer && mWindowRenderer->AsKnowsCompositor()) {
+    maxSize = std::min(
+        maxSize, mWindowRenderer->AsKnowsCompositor()->GetMaxTextureSize());
+  }
+  if (result.width > maxSize) {
+    result.width = maxSize;
+  }
+  if (result.height > maxSize) {
+    result.height = maxSize;
+  }
+  return result;
+}
+
+void nsWindow::SetTransparencyMode(nsTransparencyMode aMode) {
+  bool isTransparent = aMode == eTransparencyTransparent;
+
+  if (mIsTransparent == isTransparent) {
+    return;
+  }
+
+  if (mWindowType != eWindowType_popup) {
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1344839 reported
+    // problems cleaning the layer manager for toplevel windows.
+    // Ignore the request so as to workaround that.
+    // mIsTransparent is set in Create() if transparency may be required.
+    if (isTransparent) {
+      NS_WARNING("Transparent mode not supported on non-popup windows.");
+    }
+    return;
+  }
+
+  if (!isTransparent) {
+    ClearTransparencyBitmap();
+  }  // else the new default alpha values are "all 1", so we don't
+  // need to change anything yet
+
+  mIsTransparent = isTransparent;
+
+  if (!mHasAlphaVisual) {
+    // The choice of layer manager depends on
+    // GtkCompositorWidgetInitData::Shaped(), which will need to change, so
+    // clean out the old layer manager.
+    DestroyLayerManager();
+  }
+}
+
+nsTransparencyMode nsWindow::GetTransparencyMode() {
+  return mIsTransparent ? eTransparencyTransparent : eTransparencyOpaque;
+}
+
+gint nsWindow::GetInputRegionMarginInGdkCoords() {
+  return DevicePixelsToGdkCoordRoundDown(mInputRegion.mMargin);
+}
+
+void nsWindow::SetInputRegion(const InputRegion& aInputRegion) {
+  mInputRegion = aInputRegion;
+
+  GdkWindow* window =
+      mDrawToContainer ? gtk_widget_get_window(mShell) : mGdkWindow;
+  if (!window) {
+    return;
+  }
+
+  LOG("nsWindow::SetInputRegion(%d, %d)", aInputRegion.mFullyTransparent,
+      int(aInputRegion.mMargin));
+
+  cairo_rectangle_int_t rect = {0, 0, 0, 0};
+  cairo_region_t* region = nullptr;
+  auto releaseRegion = MakeScopeExit([&] {
+    if (region) {
+      cairo_region_destroy(region);
+    }
+  });
+
+  if (aInputRegion.mFullyTransparent) {
+    region = cairo_region_create_rectangle(&rect);
+  } else if (aInputRegion.mMargin != 0) {
+    LayoutDeviceIntRect inputRegion(LayoutDeviceIntPoint(), mLastSizeRequest);
+    inputRegion.Deflate(aInputRegion.mMargin);
+    GdkRectangle gdkRect = DevicePixelsToGdkRectRoundOut(inputRegion);
+    rect = {gdkRect.x, gdkRect.y, gdkRect.width, gdkRect.height};
+    region = cairo_region_create_rectangle(&rect);
+  }
+
+  gdk_window_input_shape_combine_region(window, region, 0, 0);
+
+  // On Wayland gdk_window_input_shape_combine_region() call is cached and
+  // applied to underlying wl_surface when GdkWindow is repainted.
+  // Force repaint of GdkWindow to apply the change immediately.
+  if (GdkIsWaylandDisplay()) {
+    gdk_window_invalidate_rect(window, nullptr, false);
+  }
+}
+
+// For setting the draggable titlebar region from CSS
+// with -moz-window-dragging: drag.
+void nsWindow::UpdateWindowDraggingRegion(
+    const LayoutDeviceIntRegion& aRegion) {
+  if (mDraggableRegion != aRegion) {
+    mDraggableRegion = aRegion;
+  }
+}
+
+LayoutDeviceIntCoord nsWindow::GetTitlebarRadius() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  int32_t cssCoord = LookAndFeel::GetInt(LookAndFeel::IntID::TitlebarRadius);
+  return GdkCoordToDevicePixels(cssCoord);
+}
+
+// See subtract_corners_from_region() at gtk/gtkwindow.c
+// We need to subtract corners from toplevel window opaque region
+// to draw transparent corners of default Gtk titlebar.
+// Both implementations (cairo_region_t and wl_region) needs to be synced.
+static void SubtractTitlebarCorners(cairo_region_t* aRegion, int aX, int aY,
+                                    int aWindowWidth, int aTitlebarRadius) {
+  if (!aTitlebarRadius) {
+    return;
+  }
+  cairo_rectangle_int_t rect = {aX, aY, aTitlebarRadius, aTitlebarRadius};
+  cairo_region_subtract_rectangle(aRegion, &rect);
+  rect = {
+      aX + aWindowWidth - aTitlebarRadius,
+      aY,
+      aTitlebarRadius,
+      aTitlebarRadius,
+  };
+  cairo_region_subtract_rectangle(aRegion, &rect);
+}
+
+void nsWindow::UpdateTopLevelOpaqueRegion(void) {
+  if (!mCompositedScreen) {
+    return;
+  }
+
+  GdkWindow* window =
+      mDrawToContainer ? gtk_widget_get_window(mShell) : mGdkWindow;
+  if (!window) {
+    return;
+  }
+  MOZ_ASSERT(gdk_window_get_window_type(window) == GDK_WINDOW_TOPLEVEL);
+
+  int x = 0;
+  int y = 0;
+
+  if (mDrawToContainer) {
+    gdk_window_get_position(mGdkWindow, &x, &y);
+  }
+
+  int width = DevicePixelsToGdkCoordRoundDown(mBounds.width);
+  int height = DevicePixelsToGdkCoordRoundDown(mBounds.height);
+
+  cairo_region_t* region = cairo_region_create();
+  cairo_rectangle_int_t rect = {x, y, width, height};
+  cairo_region_union_rectangle(region, &rect);
+
+  int radius = DoDrawTilebarCorners() ? int(GetTitlebarRadius()) : 0;
+  SubtractTitlebarCorners(region, x, y, width, radius);
+
+  gdk_window_set_opaque_region(window, region);
+
+  cairo_region_destroy(region);
+
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay()) {
+    moz_container_wayland_update_opaque_region(mContainer, radius);
+  }
+#endif
+}
+
+bool nsWindow::IsChromeWindowTitlebar() {
+  return mDrawInTitlebar && !mIsPIPWindow &&
+         mWindowType == eWindowType_toplevel;
+}
+
+bool nsWindow::DoDrawTilebarCorners() {
+  return IsChromeWindowTitlebar() && mSizeMode == nsSizeMode_Normal &&
+         !mIsTiled;
+}
+
+void nsWindow::ResizeTransparencyBitmap() {
+  if (!mTransparencyBitmap) return;
+
+  if (mBounds.width == mTransparencyBitmapWidth &&
+      mBounds.height == mTransparencyBitmapHeight) {
+    return;
+  }
+
+  int32_t newRowBytes = GetBitmapStride(mBounds.width);
+  int32_t newSize = newRowBytes * mBounds.height;
+  auto* newBits = new gchar[newSize];
+  // fill new mask with "transparent", first
+  memset(newBits, 0, newSize);
+
+  // Now copy the intersection of the old and new areas into the new mask
+  int32_t copyWidth = std::min(mBounds.width, mTransparencyBitmapWidth);
+  int32_t copyHeight = std::min(mBounds.height, mTransparencyBitmapHeight);
+  int32_t oldRowBytes = GetBitmapStride(mTransparencyBitmapWidth);
+  int32_t copyBytes = GetBitmapStride(copyWidth);
+
+  int32_t i;
+  gchar* fromPtr = mTransparencyBitmap;
+  gchar* toPtr = newBits;
+  for (i = 0; i < copyHeight; i++) {
+    memcpy(toPtr, fromPtr, copyBytes);
+    fromPtr += oldRowBytes;
+    toPtr += newRowBytes;
+  }
+
+  delete[] mTransparencyBitmap;
+  mTransparencyBitmap = newBits;
+  mTransparencyBitmapWidth = mBounds.width;
+  mTransparencyBitmapHeight = mBounds.height;
+}
+
+static bool ChangedMaskBits(gchar* aMaskBits, int32_t aMaskWidth,
+                            int32_t aMaskHeight, const nsIntRect& aRect,
+                            uint8_t* aAlphas, int32_t aStride) {
+  int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost();
+  int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth);
+  for (y = aRect.y; y < yMax; y++) {
+    gchar* maskBytes = aMaskBits + y * maskBytesPerRow;
+    uint8_t* alphas = aAlphas;
+    for (x = aRect.x; x < xMax; x++) {
+      bool newBit = *alphas > 0x7f;
+      alphas++;
+
+      gchar maskByte = maskBytes[x >> 3];
+      bool maskBit = (maskByte & (1 << (x & 7))) != 0;
+
+      if (maskBit != newBit) {
+        return true;
+      }
+    }
+    aAlphas += aStride;
+  }
+
+  return false;
+}
+
+static void UpdateMaskBits(gchar* aMaskBits, int32_t aMaskWidth,
+                           int32_t aMaskHeight, const nsIntRect& aRect,
+                           uint8_t* aAlphas, int32_t aStride) {
+  int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost();
+  int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth);
+  for (y = aRect.y; y < yMax; y++) {
+    gchar* maskBytes = aMaskBits + y * maskBytesPerRow;
+    uint8_t* alphas = aAlphas;
+    for (x = aRect.x; x < xMax; x++) {
+      bool newBit = *alphas > 0x7f;
+      alphas++;
+
+      gchar mask = 1 << (x & 7);
+      gchar maskByte = maskBytes[x >> 3];
+      // Note: '-newBit' turns 0 into 00...00 and 1 into 11...11
+      maskBytes[x >> 3] = (maskByte & ~mask) | (-newBit & mask);
+    }
+    aAlphas += aStride;
+  }
+}
+
+void nsWindow::ApplyTransparencyBitmap() {
+#ifdef MOZ_X11
+  // We use X11 calls where possible, because GDK handles expose events
+  // for shaped windows in a way that's incompatible with us (Bug 635903).
+  // It doesn't occur when the shapes are set through X.
+  Display* xDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow);
+  Window xDrawable = GDK_WINDOW_XID(mGdkWindow);
+  Pixmap maskPixmap = XCreateBitmapFromData(
+      xDisplay, xDrawable, mTransparencyBitmap, mTransparencyBitmapWidth,
+      mTransparencyBitmapHeight);
+  XShapeCombineMask(xDisplay, xDrawable, ShapeBounding, 0, 0, maskPixmap,
+                    ShapeSet);
+  XFreePixmap(xDisplay, maskPixmap);
+#endif  // MOZ_X11
+}
+
+void nsWindow::ClearTransparencyBitmap() {
+  if (!mTransparencyBitmap) return;
+
+  delete[] mTransparencyBitmap;
+  mTransparencyBitmap = nullptr;
+  mTransparencyBitmapWidth = 0;
+  mTransparencyBitmapHeight = 0;
+
+  if (!mShell) return;
+
+#ifdef MOZ_X11
+  if (MOZ_UNLIKELY(!mGdkWindow)) {
+    return;
+  }
+
+  Display* xDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow);
+  Window xWindow = gdk_x11_window_get_xid(mGdkWindow);
+
+  XShapeCombineMask(xDisplay, xWindow, ShapeBounding, 0, 0, X11None, ShapeSet);
+#endif
+}
+
+nsresult nsWindow::UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect,
+                                                        uint8_t* aAlphas,
+                                                        int32_t aStride) {
+  NS_ASSERTION(mIsTransparent, "Window is not transparent");
+  NS_ASSERTION(!mTransparencyBitmapForTitlebar,
+               "Transparency bitmap is already used for titlebar rendering");
+
+  if (mTransparencyBitmap == nullptr) {
+    int32_t size = GetBitmapStride(mBounds.width) * mBounds.height;
+    mTransparencyBitmap = new gchar[size];
+    memset(mTransparencyBitmap, 255, size);
+    mTransparencyBitmapWidth = mBounds.width;
+    mTransparencyBitmapHeight = mBounds.height;
+  } else {
+    ResizeTransparencyBitmap();
+  }
+
+  nsIntRect rect;
+  rect.IntersectRect(aRect, nsIntRect(0, 0, mBounds.width, mBounds.height));
+
+  if (!ChangedMaskBits(mTransparencyBitmap, mBounds.width, mBounds.height, rect,
+                       aAlphas, aStride)) {
+    // skip the expensive stuff if the mask bits haven't changed; hopefully
+    // this is the common case
+    return NS_OK;
+  }
+
+  UpdateMaskBits(mTransparencyBitmap, mBounds.width, mBounds.height, rect,
+                 aAlphas, aStride);
+
+  if (!mNeedsShow) {
+    ApplyTransparencyBitmap();
+  }
+  return NS_OK;
+}
+
+#define TITLEBAR_HEIGHT 10
+
+LayoutDeviceIntRect nsWindow::GetTitlebarRect() {
+  if (!mGdkWindow || !mDrawInTitlebar) {
+    return LayoutDeviceIntRect();
+  }
+
+  int height = 0;
+  if (DoDrawTilebarCorners()) {
+    height = GdkCeiledScaleFactor() * TITLEBAR_HEIGHT;
+  }
+  return LayoutDeviceIntRect(0, 0, mBounds.width, height);
+}
+
+void nsWindow::UpdateTitlebarTransparencyBitmap() {
+  NS_ASSERTION(mTransparencyBitmapForTitlebar,
+               "Transparency bitmap is already used to draw window shape");
+
+  if (!mGdkWindow || !mDrawInTitlebar ||
+      (mBounds.width == mTransparencyBitmapWidth &&
+       mBounds.height == mTransparencyBitmapHeight)) {
+    return;
+  }
+
+  bool maskCreate =
+      !mTransparencyBitmap || mBounds.width > mTransparencyBitmapWidth;
+
+  bool maskUpdate =
+      !mTransparencyBitmap || mBounds.width != mTransparencyBitmapWidth;
+
+  LayoutDeviceIntCoord radius = GetTitlebarRadius();
+  if (maskCreate) {
+    delete[] mTransparencyBitmap;
+    int32_t size = GetBitmapStride(mBounds.width) * radius;
+    mTransparencyBitmap = new gchar[size];
+    mTransparencyBitmapWidth = mBounds.width;
+  } else {
+    mTransparencyBitmapWidth = mBounds.width;
+  }
+  mTransparencyBitmapHeight = mBounds.height;
+
+  if (maskUpdate) {
+    cairo_surface_t* surface = cairo_image_surface_create(
+        CAIRO_FORMAT_A8, mTransparencyBitmapWidth, radius);
+    if (!surface) return;
+
+    cairo_t* cr = cairo_create(surface);
+
+    GtkWidgetState state;
+    memset((void*)&state, 0, sizeof(state));
+    GdkRectangle rect = {0, 0, mTransparencyBitmapWidth, radius};
+
+    moz_gtk_widget_paint(MOZ_GTK_HEADER_BAR, cr, &rect, &state, 0,
+                         GTK_TEXT_DIR_NONE);
+
+    cairo_destroy(cr);
+    cairo_surface_mark_dirty(surface);
+    cairo_surface_flush(surface);
+
+    UpdateMaskBits(mTransparencyBitmap, mTransparencyBitmapWidth, radius,
+                   nsIntRect(0, 0, mTransparencyBitmapWidth, radius),
+                   cairo_image_surface_get_data(surface),
+                   cairo_format_stride_for_width(CAIRO_FORMAT_A8,
+                                                 mTransparencyBitmapWidth));
+
+    cairo_surface_destroy(surface);
+  }
+
+#ifdef MOZ_X11
+  if (!mNeedsShow) {
+    Display* xDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow);
+    Window xDrawable = GDK_WINDOW_XID(mGdkWindow);
+
+    Pixmap maskPixmap =
+        XCreateBitmapFromData(xDisplay, xDrawable, mTransparencyBitmap,
+                              mTransparencyBitmapWidth, radius);
+
+    XShapeCombineMask(xDisplay, xDrawable, ShapeBounding, 0, 0, maskPixmap,
+                      ShapeSet);
+
+    if (mTransparencyBitmapHeight > radius) {
+      XRectangle rect = {0, 0, (unsigned short)mTransparencyBitmapWidth,
+                         (unsigned short)(mTransparencyBitmapHeight - radius)};
+      XShapeCombineRectangles(xDisplay, xDrawable, ShapeBounding, 0, radius,
+                              &rect, 1, ShapeUnion, 0);
+    }
+
+    XFreePixmap(xDisplay, maskPixmap);
+  }
+#endif
+}
+
+GtkWidget* nsWindow::GetToplevelWidget() const { return mShell; }
+
+GdkWindow* nsWindow::GetToplevelGdkWindow() const {
+  return gtk_widget_get_window(mShell);
+}
+
+nsWindow* nsWindow::GetContainerWindow() const {
+  GtkWidget* owningWidget = GTK_WIDGET(mContainer);
+  if (!owningWidget) {
+    return nullptr;
+  }
+
+  nsWindow* window = get_window_for_gtk_widget(owningWidget);
+  NS_ASSERTION(window, "No nsWindow for container widget");
+  return window;
+}
+
+void nsWindow::SetUrgencyHint(GtkWidget* top_window, bool state) {
+  LOG("  nsWindow::SetUrgencyHint widget %p\n", top_window);
+
+  if (!top_window) return;
+
+  // TODO: Use xdg-activation on Wayland?
+  gdk_window_set_urgency_hint(gtk_widget_get_window(top_window), state);
+}
+
+void nsWindow::SetDefaultIcon(void) { SetIcon(u"default"_ns); }
+
+gint nsWindow::ConvertBorderStyles(nsBorderStyle aStyle) {
+  gint w = 0;
+
+  if (aStyle == eBorderStyle_default) return -1;
+
+  // note that we don't handle eBorderStyle_close yet
+  if (aStyle & eBorderStyle_all) w |= GDK_DECOR_ALL;
+  if (aStyle & eBorderStyle_border) w |= GDK_DECOR_BORDER;
+  if (aStyle & eBorderStyle_resizeh) w |= GDK_DECOR_RESIZEH;
+  if (aStyle & eBorderStyle_title) w |= GDK_DECOR_TITLE;
+  if (aStyle & eBorderStyle_menu) w |= GDK_DECOR_MENU;
+  if (aStyle & eBorderStyle_minimize) w |= GDK_DECOR_MINIMIZE;
+  if (aStyle & eBorderStyle_maximize) w |= GDK_DECOR_MAXIMIZE;
+
+  return w;
+}
+
+class FullscreenTransitionWindow final : public nsISupports {
+ public:
+  NS_DECL_ISUPPORTS
+
+  explicit FullscreenTransitionWindow(GtkWidget* aWidget);
+
+  GtkWidget* mWindow;
+
+ private:
+  ~FullscreenTransitionWindow();
+};
+
+NS_IMPL_ISUPPORTS0(FullscreenTransitionWindow)
+
+FullscreenTransitionWindow::FullscreenTransitionWindow(GtkWidget* aWidget) {
+  mWindow = gtk_window_new(GTK_WINDOW_POPUP);
+  GtkWindow* gtkWin = GTK_WINDOW(mWindow);
+
+  gtk_window_set_type_hint(gtkWin, GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
+  GtkWindowSetTransientFor(gtkWin, GTK_WINDOW(aWidget));
+  gtk_window_set_decorated(gtkWin, false);
+
+  GdkWindow* gdkWin = gtk_widget_get_window(aWidget);
+  GdkScreen* screen = gtk_widget_get_screen(aWidget);
+  gint monitorNum = gdk_screen_get_monitor_at_window(screen, gdkWin);
+  GdkRectangle monitorRect;
+  gdk_screen_get_monitor_geometry(screen, monitorNum, &monitorRect);
+  gtk_window_set_screen(gtkWin, screen);
+  gtk_window_move(gtkWin, monitorRect.x, monitorRect.y);
+  MOZ_ASSERT(monitorRect.width > 0 && monitorRect.height > 0,
+             "Can't resize window smaller than 1x1.");
+  gtk_window_resize(gtkWin, monitorRect.width, monitorRect.height);
+
+  GdkRGBA bgColor;
+  bgColor.red = bgColor.green = bgColor.blue = 0.0;
+  bgColor.alpha = 1.0;
+  gtk_widget_override_background_color(mWindow, GTK_STATE_FLAG_NORMAL,
+                                       &bgColor);
+
+  gtk_widget_set_opacity(mWindow, 0.0);
+  gtk_widget_show(mWindow);
+}
+
+FullscreenTransitionWindow::~FullscreenTransitionWindow() {
+  gtk_widget_destroy(mWindow);
+}
+
+class FullscreenTransitionData {
+ public:
+  FullscreenTransitionData(nsIWidget::FullscreenTransitionStage aStage,
+                           uint16_t aDuration, nsIRunnable* aCallback,
+                           FullscreenTransitionWindow* aWindow)
+      : mStage(aStage),
+        mStartTime(TimeStamp::Now()),
+        mDuration(TimeDuration::FromMilliseconds(aDuration)),
+        mCallback(aCallback),
+        mWindow(aWindow) {}
+
+  static const guint sInterval = 1000 / 30;  // 30fps
+  static gboolean TimeoutCallback(gpointer aData);
+
+ private:
+  nsIWidget::FullscreenTransitionStage mStage;
+  TimeStamp mStartTime;
+  TimeDuration mDuration;
+  nsCOMPtr<nsIRunnable> mCallback;
+  RefPtr<FullscreenTransitionWindow> mWindow;
+};
+
+/* static */
+gboolean FullscreenTransitionData::TimeoutCallback(gpointer aData) {
+  bool finishing = false;
+  auto* data = static_cast<FullscreenTransitionData*>(aData);
+  gdouble opacity = (TimeStamp::Now() - data->mStartTime) / data->mDuration;
+  if (opacity >= 1.0) {
+    opacity = 1.0;
+    finishing = true;
+  }
+  if (data->mStage == nsIWidget::eAfterFullscreenToggle) {
+    opacity = 1.0 - opacity;
+  }
+  gtk_widget_set_opacity(data->mWindow->mWindow, opacity);
+
+  if (!finishing) {
+    return TRUE;
+  }
+  NS_DispatchToMainThread(data->mCallback.forget());
+  delete data;
+  return FALSE;
+}
+
+/* virtual */
+bool nsWindow::PrepareForFullscreenTransition(nsISupports** aData) {
+  if (!mCompositedScreen) {
+    return false;
+  }
+  *aData = do_AddRef(new FullscreenTransitionWindow(mShell)).take();
+  return true;
+}
+
+/* virtual */
+void nsWindow::PerformFullscreenTransition(FullscreenTransitionStage aStage,
+                                           uint16_t aDuration,
+                                           nsISupports* aData,
+                                           nsIRunnable* aCallback) {
+  auto* data = static_cast<FullscreenTransitionWindow*>(aData);
+  // This will be released at the end of the last timeout callback for it.
+  auto* transitionData =
+      new FullscreenTransitionData(aStage, aDuration, aCallback, data);
+  g_timeout_add_full(G_PRIORITY_HIGH, FullscreenTransitionData::sInterval,
+                     FullscreenTransitionData::TimeoutCallback, transitionData,
+                     nullptr);
+}
+
+already_AddRefed<nsIScreen> nsWindow::GetWidgetScreen() {
+  // Wayland can read screen directly
+  if (GdkIsWaylandDisplay()) {
+    RefPtr<nsIScreen> screen = ScreenHelperGTK::GetScreenForWindow(this);
+    if (screen) {
+      return screen.forget();
+    }
+  }
+
+  nsCOMPtr<nsIScreenManager> screenManager;
+  screenManager = do_GetService("@mozilla.org/gfx/screenmanager;1");
+  if (!screenManager) {
+    return nullptr;
+  }
+
+  // GetScreenBounds() is slow for the GTK port so we override and use
+  // mBounds directly.
+  LayoutDeviceIntRect bounds = mBounds;
+  DesktopIntRect deskBounds = RoundedToInt(bounds / GetDesktopToDeviceScale());
+  nsCOMPtr<nsIScreen> screen;
+  screenManager->ScreenForRect(deskBounds.x, deskBounds.y, deskBounds.width,
+                               deskBounds.height, getter_AddRefs(screen));
+  return screen.forget();
+}
+
+RefPtr<VsyncDispatcher> nsWindow::GetVsyncDispatcher() {
+#ifdef MOZ_WAYLAND
+  if (mWaylandVsyncDispatcher) {
+    return mWaylandVsyncDispatcher;
+  }
+#endif
+  return nullptr;
+}
+
+bool nsWindow::SynchronouslyRepaintOnResize() {
+  if (GdkIsWaylandDisplay()) {
+    // See Bug 1734368
+    // Don't request synchronous repaint on HW accelerated backend - mesa can be
+    // deadlocked when it's missing back buffer and main event loop is blocked.
+    return false;
+  }
+
+  // default is synced repaint.
+  return true;
+}
+
+static bool IsFullscreenSupported(GtkWidget* aShell) {
+#ifdef MOZ_X11
+  GdkScreen* screen = gtk_widget_get_screen(aShell);
+  GdkAtom atom = gdk_atom_intern("_NET_WM_STATE_FULLSCREEN", FALSE);
+  return gdk_x11_screen_supports_net_wm_hint(screen, atom);
+#else
+  return true;
+#endif
+}
+
+nsresult nsWindow::MakeFullScreen(bool aFullScreen) {
+  LOG("nsWindow::MakeFullScreen aFullScreen %d\n", aFullScreen);
+
+  if (GdkIsX11Display() && !IsFullscreenSupported(mShell)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (aFullScreen) {
+    if (mSizeMode != nsSizeMode_Fullscreen &&
+        mSizeMode != nsSizeMode_Minimized) {
+      mLastSizeModeBeforeFullscreen = mSizeMode;
+    }
+    if (mIsPIPWindow) {
+      gtk_window_set_type_hint(GTK_WINDOW(mShell), GDK_WINDOW_TYPE_HINT_NORMAL);
+      if (gUseAspectRatio) {
+        mAspectRatioSaved = mAspectRatio;
+        mAspectRatio = 0.0f;
+        ApplySizeConstraints();
+      }
+    }
+
+    gtk_window_fullscreen(GTK_WINDOW(mShell));
+  } else {
+    gtk_window_unfullscreen(GTK_WINDOW(mShell));
+
+    if (mIsPIPWindow) {
+      gtk_window_set_type_hint(GTK_WINDOW(mShell),
+                               GDK_WINDOW_TYPE_HINT_UTILITY);
+      if (gUseAspectRatio) {
+        mAspectRatio = mAspectRatioSaved;
+        // ApplySizeConstraints();
+      }
+    }
+  }
+
+  MOZ_ASSERT(mLastSizeModeBeforeFullscreen != nsSizeMode_Fullscreen);
+  return NS_OK;
+}
+
+void nsWindow::SetWindowDecoration(nsBorderStyle aStyle) {
+  LOG("nsWindow::SetWindowDecoration() Border style %x\n", aStyle);
+
+  // We can't use mGdkWindow directly here as it can be
+  // derived from mContainer which is not a top-level GdkWindow.
+  GdkWindow* window = gtk_widget_get_window(mShell);
+
+  // Sawfish, metacity, and presumably other window managers get
+  // confused if we change the window decorations while the window
+  // is visible.
+  bool wasVisible = false;
+  if (gdk_window_is_visible(window)) {
+    gdk_window_hide(window);
+    wasVisible = true;
+  }
+
+  gint wmd = ConvertBorderStyles(aStyle);
+  if (wmd != -1) gdk_window_set_decorations(window, (GdkWMDecoration)wmd);
+
+  if (wasVisible) gdk_window_show(window);
+
+    // For some window managers, adding or removing window decorations
+    // requires unmapping and remapping our toplevel window.  Go ahead
+    // and flush the queue here so that we don't end up with a BadWindow
+    // error later when this happens (when the persistence timer fires
+    // and GetWindowPos is called)
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    XSync(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), X11False);
+  } else
+#endif /* MOZ_X11 */
+  {
+    gdk_flush();
+  }
+}
+
+void nsWindow::HideWindowChrome(bool aShouldHide) {
+  SetWindowDecoration(aShouldHide ? eBorderStyle_none : mBorderStyle);
+}
+
+bool nsWindow::CheckForRollup(gdouble aMouseX, gdouble aMouseY, bool aIsWheel,
+                              bool aAlwaysRollup) {
+  LOG("nsWindow::CheckForRollup() aAlwaysRollup %d", aAlwaysRollup);
+  nsIRollupListener* rollupListener = GetActiveRollupListener();
+  nsCOMPtr<nsIWidget> rollupWidget;
+  if (rollupListener) {
+    rollupWidget = rollupListener->GetRollupWidget();
+  }
+  if (!rollupWidget) {
+    return false;
+  }
+
+  bool retVal = false;
+  auto* currentPopup =
+      (GdkWindow*)rollupWidget->GetNativeData(NS_NATIVE_WINDOW);
+  if (aAlwaysRollup || !is_mouse_in_window(currentPopup, aMouseX, aMouseY)) {
+    bool rollup = true;
+    if (aIsWheel) {
+      rollup = rollupListener->ShouldRollupOnMouseWheelEvent();
+      retVal = rollupListener->ShouldConsumeOnMouseWheelEvent();
+    }
+    // if we're dealing with menus, we probably have submenus and
+    // we don't want to rollup if the click is in a parent menu of
+    // the current submenu
+    uint32_t popupsToRollup = UINT32_MAX;
+    if (!aAlwaysRollup) {
+      AutoTArray<nsIWidget*, 5> widgetChain;
+      uint32_t sameTypeCount =
+          rollupListener->GetSubmenuWidgetChain(&widgetChain);
+      for (unsigned long i = 0; i < widgetChain.Length(); ++i) {
+        nsIWidget* widget = widgetChain[i];
+        auto* currWindow = (GdkWindow*)widget->GetNativeData(NS_NATIVE_WINDOW);
+        if (is_mouse_in_window(currWindow, aMouseX, aMouseY)) {
+          // don't roll up if the mouse event occurred within a
+          // menu of the same type. If the mouse event occurred
+          // in a menu higher than that, roll up, but pass the
+          // number of popups to Rollup so that only those of the
+          // same type close up.
+          if (i < sameTypeCount) {
+            rollup = false;
+          } else {
+            popupsToRollup = sameTypeCount;
+          }
+          break;
+        }
+      }  // foreach parent menu widget
+    }    // if rollup listener knows about menus
+
+    // if we've determined that we should still rollup, do it.
+    bool usePoint = !aIsWheel && !aAlwaysRollup;
+    LayoutDeviceIntPoint point;
+    if (usePoint) {
+      point = GdkEventCoordsToDevicePixels(aMouseX, aMouseY);
+    }
+    if (rollup &&
+        rollupListener->Rollup(popupsToRollup, true,
+                               usePoint ? &point : nullptr, nullptr)) {
+      retVal = true;
+    }
+  }
+  return retVal;
+}
+
+/* static */
+bool nsWindow::DragInProgress() {
+  nsCOMPtr<nsIDragService> dragService =
+      do_GetService("@mozilla.org/widget/dragservice;1");
+  if (!dragService) {
+    return false;
+  }
+
+  nsCOMPtr<nsIDragSession> currentDragSession;
+  dragService->GetCurrentSession(getter_AddRefs(currentDragSession));
+  return !!currentDragSession;
+}
+
+// This is an ugly workaround for
+// https://bugzilla.mozilla.org/show_bug.cgi?id=1622107
+// We try to detect when Wayland compositor / gtk fails to deliver
+// info about finished D&D operations and cancel it on our own.
+MOZ_CAN_RUN_SCRIPT static void WaylandDragWorkaround(GdkEventButton* aEvent) {
+  static int buttonPressCountWithDrag = 0;
+
+  // We track only left button state as Firefox performs D&D on left
+  // button only.
+  if (aEvent->button != 1 || aEvent->type != GDK_BUTTON_PRESS) {
+    return;
+  }
+
+  nsCOMPtr<nsIDragService> dragService =
+      do_GetService("@mozilla.org/widget/dragservice;1");
+  if (!dragService) {
+    return;
+  }
+  nsCOMPtr<nsIDragSession> currentDragSession;
+  dragService->GetCurrentSession(getter_AddRefs(currentDragSession));
+
+  if (!currentDragSession) {
+    buttonPressCountWithDrag = 0;
+    return;
+  }
+
+  buttonPressCountWithDrag++;
+  if (buttonPressCountWithDrag > 1) {
+    NS_WARNING(
+        "Quit unfinished Wayland Drag and Drop operation. Buggy Wayland "
+        "compositor?");
+    buttonPressCountWithDrag = 0;
+    dragService->EndDragSession(false, 0);
+  }
+}
+
+static nsWindow* get_window_for_gtk_widget(GtkWidget* widget) {
+  gpointer user_data = g_object_get_data(G_OBJECT(widget), "nsWindow");
+  return static_cast<nsWindow*>(user_data);
+}
+
+static nsWindow* get_window_for_gdk_window(GdkWindow* window) {
+  gpointer user_data = g_object_get_data(G_OBJECT(window), "nsWindow");
+  return static_cast<nsWindow*>(user_data);
+}
+
+static bool is_mouse_in_window(GdkWindow* aWindow, gdouble aMouseX,
+                               gdouble aMouseY) {
+  GdkWindow* window = aWindow;
+  if (!window) {
+    return false;
+  }
+
+  gint x = 0;
+  gint y = 0;
+
+  {
+    gint offsetX = 0;
+    gint offsetY = 0;
+
+    while (window) {
+      gint tmpX = 0;
+      gint tmpY = 0;
+
+      gdk_window_get_position(window, &tmpX, &tmpY);
+      GtkWidget* widget = get_gtk_widget_for_gdk_window(window);
+
+      // if this is a window, compute x and y given its origin and our
+      // offset
+      if (GTK_IS_WINDOW(widget)) {
+        x = tmpX + offsetX;
+        y = tmpY + offsetY;
+        break;
+      }
+
+      offsetX += tmpX;
+      offsetY += tmpY;
+      window = gdk_window_get_parent(window);
+    }
+  }
+
+  gint margin = 0;
+  if (nsWindow* w = get_window_for_gdk_window(aWindow)) {
+    margin = w->GetInputRegionMarginInGdkCoords();
+  }
+
+  x += margin;
+  y += margin;
+
+  gint w = gdk_window_get_width(aWindow) - margin;
+  gint h = gdk_window_get_height(aWindow) - margin;
+
+  return aMouseX > x && aMouseX < x + w && aMouseY > y && aMouseY < y + h;
+}
+
+static GtkWidget* get_gtk_widget_for_gdk_window(GdkWindow* window) {
+  gpointer user_data = nullptr;
+  gdk_window_get_user_data(window, &user_data);
+
+  return GTK_WIDGET(user_data);
+}
+
+static GdkCursor* get_gtk_cursor(nsCursor aCursor) {
+  GdkCursor* gdkcursor = nullptr;
+  uint8_t newType = 0xff;
+
+  if ((gdkcursor = gCursorCache[aCursor])) {
+    return gdkcursor;
+  }
+
+  GdkDisplay* defaultDisplay = gdk_display_get_default();
+
+  // The strategy here is to use standard GDK cursors, and, if not available,
+  // load by standard name with gdk_cursor_new_from_name.
+  // Spec is here: http://www.freedesktop.org/wiki/Specifications/cursor-spec/
+  switch (aCursor) {
+    case eCursor_standard:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_LEFT_PTR);
+      break;
+    case eCursor_wait:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_WATCH);
+      break;
+    case eCursor_select:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_XTERM);
+      break;
+    case eCursor_hyperlink:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_HAND2);
+      break;
+    case eCursor_n_resize:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_TOP_SIDE);
+      break;
+    case eCursor_s_resize:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_BOTTOM_SIDE);
+      break;
+    case eCursor_w_resize:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_LEFT_SIDE);
+      break;
+    case eCursor_e_resize:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_RIGHT_SIDE);
+      break;
+    case eCursor_nw_resize:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_TOP_LEFT_CORNER);
+      break;
+    case eCursor_se_resize:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_BOTTOM_RIGHT_CORNER);
+      break;
+    case eCursor_ne_resize:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_TOP_RIGHT_CORNER);
+      break;
+    case eCursor_sw_resize:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_BOTTOM_LEFT_CORNER);
+      break;
+    case eCursor_crosshair:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_CROSSHAIR);
+      break;
+    case eCursor_move:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_FLEUR);
+      break;
+    case eCursor_help:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_QUESTION_ARROW);
+      break;
+    case eCursor_copy:  // CSS3
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "copy");
+      if (!gdkcursor) newType = MOZ_CURSOR_COPY;
+      break;
+    case eCursor_alias:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "alias");
+      if (!gdkcursor) newType = MOZ_CURSOR_ALIAS;
+      break;
+    case eCursor_context_menu:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "context-menu");
+      if (!gdkcursor) newType = MOZ_CURSOR_CONTEXT_MENU;
+      break;
+    case eCursor_cell:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_PLUS);
+      break;
+    // Those two aren’t standardized. Trying both KDE’s and GNOME’s names
+    case eCursor_grab:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "openhand");
+      if (!gdkcursor) newType = MOZ_CURSOR_HAND_GRAB;
+      break;
+    case eCursor_grabbing:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "closedhand");
+      if (!gdkcursor) {
+        gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "grabbing");
+      }
+      if (!gdkcursor) newType = MOZ_CURSOR_HAND_GRABBING;
+      break;
+    case eCursor_spinning:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "progress");
+      if (!gdkcursor) newType = MOZ_CURSOR_SPINNING;
+      break;
+    case eCursor_zoom_in:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "zoom-in");
+      if (!gdkcursor) newType = MOZ_CURSOR_ZOOM_IN;
+      break;
+    case eCursor_zoom_out:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "zoom-out");
+      if (!gdkcursor) newType = MOZ_CURSOR_ZOOM_OUT;
+      break;
+    case eCursor_not_allowed:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "not-allowed");
+      if (!gdkcursor) {  // nonstandard, yet common
+        gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "crossed_circle");
+      }
+      if (!gdkcursor) newType = MOZ_CURSOR_NOT_ALLOWED;
+      break;
+    case eCursor_no_drop:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "no-drop");
+      if (!gdkcursor) {  // this nonstandard sequence makes it work on KDE and
+                         // GNOME
+        gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "forbidden");
+      }
+      if (!gdkcursor) {
+        gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "circle");
+      }
+      if (!gdkcursor) newType = MOZ_CURSOR_NOT_ALLOWED;
+      break;
+    case eCursor_vertical_text:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "vertical-text");
+      if (!gdkcursor) {
+        newType = MOZ_CURSOR_VERTICAL_TEXT;
+      }
+      break;
+    case eCursor_all_scroll:
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_FLEUR);
+      break;
+    case eCursor_nesw_resize:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "size_bdiag");
+      if (!gdkcursor) newType = MOZ_CURSOR_NESW_RESIZE;
+      break;
+    case eCursor_nwse_resize:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "size_fdiag");
+      if (!gdkcursor) newType = MOZ_CURSOR_NWSE_RESIZE;
+      break;
+    case eCursor_ns_resize:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_SB_V_DOUBLE_ARROW);
+      break;
+    case eCursor_ew_resize:
+      gdkcursor =
+          gdk_cursor_new_for_display(defaultDisplay, GDK_SB_H_DOUBLE_ARROW);
+      break;
+    // Here, two better fitting cursors exist in some cursor themes. Try those
+    // first
+    case eCursor_row_resize:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "split_v");
+      if (!gdkcursor) {
+        gdkcursor =
+            gdk_cursor_new_for_display(defaultDisplay, GDK_SB_V_DOUBLE_ARROW);
+      }
+      break;
+    case eCursor_col_resize:
+      gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "split_h");
+      if (!gdkcursor) {
+        gdkcursor =
+            gdk_cursor_new_for_display(defaultDisplay, GDK_SB_H_DOUBLE_ARROW);
+      }
+      break;
+    case eCursor_none:
+      newType = MOZ_CURSOR_NONE;
+      break;
+    default:
+      NS_ASSERTION(aCursor, "Invalid cursor type");
+      gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_LEFT_PTR);
+      break;
+  }
+
+  // If by now we don't have a xcursor, this means we have to make a custom
+  // one. First, we try creating a named cursor based on the hash of our
+  // custom bitmap, as libXcursor has some magic to convert bitmapped cursors
+  // to themed cursors
+  if (newType != 0xFF && GtkCursors[newType].hash) {
+    gdkcursor =
+        gdk_cursor_new_from_name(defaultDisplay, GtkCursors[newType].hash);
+  }
+
+  // If we still don't have a xcursor, we now really create a bitmap cursor
+  if (newType != 0xff && !gdkcursor) {
+    GdkPixbuf* cursor_pixbuf =
+        gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 32, 32);
+    if (!cursor_pixbuf) return nullptr;
+
+    guchar* data = gdk_pixbuf_get_pixels(cursor_pixbuf);
+
+    // Read data from GtkCursors and compose RGBA surface from 1bit bitmap and
+    // mask GtkCursors bits and mask are 32x32 monochrome bitmaps (1 bit for
+    // each pixel) so it's 128 byte array (4 bytes for are one bitmap row and
+    // there are 32 rows here).
+    const unsigned char* bits = GtkCursors[newType].bits;
+    const unsigned char* mask_bits = GtkCursors[newType].mask_bits;
+
+    for (int i = 0; i < 128; i++) {
+      char bit = (char)*bits++;
+      char mask = (char)*mask_bits++;
+      for (int j = 0; j < 8; j++) {
+        unsigned char pix = ~(((bit >> j) & 0x01) * 0xff);
+        *data++ = pix;
+        *data++ = pix;
+        *data++ = pix;
+        *data++ = (((mask >> j) & 0x01) * 0xff);
+      }
+    }
+
+    gdkcursor = gdk_cursor_new_from_pixbuf(
+        gdk_display_get_default(), cursor_pixbuf, GtkCursors[newType].hot_x,
+        GtkCursors[newType].hot_y);
+
+    g_object_unref(cursor_pixbuf);
+  }
+
+  gCursorCache[aCursor] = gdkcursor;
+
+  return gdkcursor;
+}
+
+// gtk callbacks
+
+void draw_window_of_widget(GtkWidget* widget, GdkWindow* aWindow, cairo_t* cr) {
+  if (gtk_cairo_should_draw_window(cr, aWindow)) {
+    RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+    if (!window) {
+      NS_WARNING("Cannot get nsWindow from GtkWidget");
+    } else {
+      cairo_save(cr);
+      gtk_cairo_transform_to_window(cr, widget, aWindow);
+      // TODO - window->OnExposeEvent() can destroy this or other windows,
+      // do we need to handle it somehow?
+      window->OnExposeEvent(cr);
+      cairo_restore(cr);
+    }
+  }
+}
+
+/* static */
+gboolean expose_event_cb(GtkWidget* widget, cairo_t* cr) {
+  draw_window_of_widget(widget, gtk_widget_get_window(widget), cr);
+
+  // A strong reference is already held during "draw" signal emission,
+  // but GTK+ 3.4 wants the object to live a little longer than that
+  // (bug 1225970).
+  g_object_ref(widget);
+  g_idle_add(
+      [](gpointer data) -> gboolean {
+        g_object_unref(data);
+        return G_SOURCE_REMOVE;
+      },
+      widget);
+
+  return FALSE;
+}
+
+static gboolean configure_event_cb(GtkWidget* widget,
+                                   GdkEventConfigure* event) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return FALSE;
+  }
+
+  return window->OnConfigureEvent(widget, event);
+}
+
+// Some Gtk widget code may call gtk_widget_unrealize() which destroys
+// mGdkWindow. We need to listen on this signal and re-create
+// mGdkWindow when we're already mapped.
+static void widget_map_cb(GtkWidget* widget) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+  window->OnMap();
+}
+
+static void widget_unmap_cb(GtkWidget* widget) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+  window->OnUnmap();
+}
+
+static void widget_unrealize_cb(GtkWidget* widget) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+  window->OnUnrealize();
+}
+
+static void size_allocate_cb(GtkWidget* widget, GtkAllocation* allocation) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+
+  window->OnSizeAllocate(allocation);
+}
+
+static void toplevel_window_size_allocate_cb(GtkWidget* widget,
+                                             GtkAllocation* allocation) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+
+  window->UpdateTopLevelOpaqueRegion();
+}
+
+static gboolean delete_event_cb(GtkWidget* widget, GdkEventAny* event) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return FALSE;
+  }
+
+  window->OnDeleteEvent();
+
+  return TRUE;
+}
+
+static gboolean enter_notify_event_cb(GtkWidget* widget,
+                                      GdkEventCrossing* event) {
+  RefPtr<nsWindow> window = get_window_for_gdk_window(event->window);
+  if (!window) {
+    return TRUE;
+  }
+
+  // We have stored leave notify - check if it's the correct one and
+  // fire it before enter notify in such case.
+  if (sStoredLeaveNotifyEvent) {
+    auto clearNofityEvent =
+        MakeScopeExit([&] { sStoredLeaveNotifyEvent = nullptr; });
+    if (event->x_root == sStoredLeaveNotifyEvent->x_root &&
+        event->y_root == sStoredLeaveNotifyEvent->y_root &&
+        window->ApplyEnterLeaveMutterWorkaround()) {
+      // Enter/Leave notify events has the same coordinates
+      // and uses know buggy window config.
+      // Consider it as a bogus one.
+      return TRUE;
+    }
+    RefPtr<nsWindow> leftWindow =
+        get_window_for_gdk_window(sStoredLeaveNotifyEvent->window);
+    if (leftWindow) {
+      leftWindow->OnLeaveNotifyEvent(sStoredLeaveNotifyEvent.get());
+    }
+  }
+
+  window->OnEnterNotifyEvent(event);
+  return TRUE;
+}
+
+static gboolean leave_notify_event_cb(GtkWidget* widget,
+                                      GdkEventCrossing* event) {
+  RefPtr<nsWindow> window = get_window_for_gdk_window(event->window);
+  if (!window) {
+    return TRUE;
+  }
+
+  if (window->ApplyEnterLeaveMutterWorkaround()) {
+    // The leave event is potentially wrong, don't fire it now but store
+    // it for further check at enter_notify_event_cb().
+    sStoredLeaveNotifyEvent.reset(reinterpret_cast<GdkEventCrossing*>(
+        gdk_event_copy(reinterpret_cast<GdkEvent*>(event))));
+  } else {
+    sStoredLeaveNotifyEvent = nullptr;
+    window->OnLeaveNotifyEvent(event);
+  }
+
+  return TRUE;
+}
+
+static nsWindow* GetFirstNSWindowForGDKWindow(GdkWindow* aGdkWindow) {
+  nsWindow* window;
+  while (!(window = get_window_for_gdk_window(aGdkWindow))) {
+    // The event has bubbled to the moz_container widget as passed into each
+    // caller's *widget parameter, but its corresponding nsWindow is an ancestor
+    // of the window that we need.  Instead, look at event->window and find the
+    // first ancestor nsWindow of it because event->window may be in a plugin.
+    aGdkWindow = gdk_window_get_parent(aGdkWindow);
+    if (!aGdkWindow) {
+      window = nullptr;
+      break;
+    }
+  }
+  return window;
+}
+
+static gboolean motion_notify_event_cb(GtkWidget* widget,
+                                       GdkEventMotion* event) {
+  UpdateLastInputEventTime(event);
+
+  RefPtr<nsWindow> window = GetFirstNSWindowForGDKWindow(event->window);
+  if (!window) return FALSE;
+
+  window->OnMotionNotifyEvent(event);
+
+  return TRUE;
+}
+
+static gboolean button_press_event_cb(GtkWidget* widget,
+                                      GdkEventButton* event) {
+  UpdateLastInputEventTime(event);
+
+  RefPtr<nsWindow> window = GetFirstNSWindowForGDKWindow(event->window);
+  if (!window) return FALSE;
+
+  window->OnButtonPressEvent(event);
+
+  if (GdkIsWaylandDisplay()) {
+    WaylandDragWorkaround(event);
+  }
+
+  return TRUE;
+}
+
+static gboolean button_release_event_cb(GtkWidget* widget,
+                                        GdkEventButton* event) {
+  UpdateLastInputEventTime(event);
+
+  RefPtr<nsWindow> window = GetFirstNSWindowForGDKWindow(event->window);
+  if (!window) return FALSE;
+
+  window->OnButtonReleaseEvent(event);
+
+  return TRUE;
+}
+
+static gboolean focus_in_event_cb(GtkWidget* widget, GdkEventFocus* event) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) return FALSE;
+
+  window->OnContainerFocusInEvent(event);
+
+  return FALSE;
+}
+
+static gboolean focus_out_event_cb(GtkWidget* widget, GdkEventFocus* event) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) return FALSE;
+
+  window->OnContainerFocusOutEvent(event);
+
+  return FALSE;
+}
+
+#ifdef MOZ_X11
+// For long-lived popup windows that don't really take focus themselves but
+// may have elements that accept keyboard input when the parent window is
+// active, focus is handled specially.  These windows include noautohide
+// panels.  (This special handling is not necessary for temporary popups where
+// the keyboard is grabbed.)
+//
+// Mousing over or clicking on these windows should not cause them to steal
+// focus from their parent windows, so, the input field of WM_HINTS is set to
+// False to request that the window manager not set the input focus to this
+// window.  http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.7
+//
+// However, these windows can still receive WM_TAKE_FOCUS messages from the
+// window manager, so they can still detect when the user has indicated that
+// they wish to direct keyboard input at these windows.  When the window
+// manager offers focus to these windows (after a mouse over or click, for
+// example), a request to make the parent window active is issued.  When the
+// parent window becomes active, keyboard events will be received.
+
+static GdkFilterReturn popup_take_focus_filter(GdkXEvent* gdk_xevent,
+                                               GdkEvent* event, gpointer data) {
+  auto* xevent = static_cast<XEvent*>(gdk_xevent);
+  if (xevent->type != ClientMessage) return GDK_FILTER_CONTINUE;
+
+  XClientMessageEvent& xclient = xevent->xclient;
+  if (xclient.message_type != gdk_x11_get_xatom_by_name("WM_PROTOCOLS")) {
+    return GDK_FILTER_CONTINUE;
+  }
+
+  Atom atom = xclient.data.l[0];
+  if (atom != gdk_x11_get_xatom_by_name("WM_TAKE_FOCUS")) {
+    return GDK_FILTER_CONTINUE;
+  }
+
+  guint32 timestamp = xclient.data.l[1];
+
+  GtkWidget* widget = get_gtk_widget_for_gdk_window(event->any.window);
+  if (!widget) return GDK_FILTER_CONTINUE;
+
+  GtkWindow* parent = gtk_window_get_transient_for(GTK_WINDOW(widget));
+  if (!parent) return GDK_FILTER_CONTINUE;
+
+  if (gtk_window_is_active(parent)) {
+    return GDK_FILTER_REMOVE;  // leave input focus on the parent
+  }
+
+  GdkWindow* parent_window = gtk_widget_get_window(GTK_WIDGET(parent));
+  if (!parent_window) return GDK_FILTER_CONTINUE;
+
+  // In case the parent has not been deconified.
+  gdk_window_show_unraised(parent_window);
+
+  // Request focus on the parent window.
+  // Use gdk_window_focus rather than gtk_window_present to avoid
+  // raising the parent window.
+  gdk_window_focus(parent_window, timestamp);
+  return GDK_FILTER_REMOVE;
+}
+#endif /* MOZ_X11 */
+
+static gboolean key_press_event_cb(GtkWidget* widget, GdkEventKey* event) {
+  LOGW("key_press_event_cb\n");
+
+  UpdateLastInputEventTime(event);
+
+  // find the window with focus and dispatch this event to that widget
+  nsWindow* window = get_window_for_gtk_widget(widget);
+  if (!window) return FALSE;
+
+  RefPtr<nsWindow> focusWindow = gFocusWindow ? gFocusWindow : window;
+
+#ifdef MOZ_X11
+  // Keyboard repeat can cause key press events to queue up when there are
+  // slow event handlers (bug 301029).  Throttle these events by removing
+  // consecutive pending duplicate KeyPress events to the same window.
+  // We use the event time of the last one.
+  // Note: GDK calls XkbSetDetectableAutorepeat so that KeyRelease events
+  // are generated only when the key is physically released.
+#  define NS_GDKEVENT_MATCH_MASK 0x1FFF  // GDK_SHIFT_MASK .. GDK_BUTTON5_MASK
+  // Our headers undefine X11 KeyPress - let's redefine it here.
+#  ifndef KeyPress
+#    define KeyPress 2
+#  endif
+  GdkDisplay* gdkDisplay = gtk_widget_get_display(widget);
+  if (GdkIsX11Display(gdkDisplay)) {
+    Display* dpy = GDK_DISPLAY_XDISPLAY(gdkDisplay);
+    while (XPending(dpy)) {
+      XEvent next_event;
+      XPeekEvent(dpy, &next_event);
+      GdkWindow* nextGdkWindow =
+          gdk_x11_window_lookup_for_display(gdkDisplay, next_event.xany.window);
+      if (nextGdkWindow != event->window || next_event.type != KeyPress ||
+          next_event.xkey.keycode != event->hardware_keycode ||
+          next_event.xkey.state != (event->state & NS_GDKEVENT_MATCH_MASK)) {
+        break;
+      }
+      XNextEvent(dpy, &next_event);
+      event->time = next_event.xkey.time;
+    }
+  }
+#endif
+
+  return focusWindow->OnKeyPressEvent(event);
+}
+
+static gboolean key_release_event_cb(GtkWidget* widget, GdkEventKey* event) {
+  LOGW("key_release_event_cb\n");
+
+  UpdateLastInputEventTime(event);
+
+  // find the window with focus and dispatch this event to that widget
+  nsWindow* window = get_window_for_gtk_widget(widget);
+  if (!window) return FALSE;
+
+  RefPtr<nsWindow> focusWindow = gFocusWindow ? gFocusWindow : window;
+  return focusWindow->OnKeyReleaseEvent(event);
+}
+
+static gboolean property_notify_event_cb(GtkWidget* aWidget,
+                                         GdkEventProperty* aEvent) {
+  RefPtr<nsWindow> window = get_window_for_gdk_window(aEvent->window);
+  if (!window) return FALSE;
+
+  return window->OnPropertyNotifyEvent(aWidget, aEvent);
+}
+
+static gboolean scroll_event_cb(GtkWidget* widget, GdkEventScroll* event) {
+  RefPtr<nsWindow> window = GetFirstNSWindowForGDKWindow(event->window);
+  if (!window) return FALSE;
+
+  window->OnScrollEvent(event);
+
+  return TRUE;
+}
+
+static void hierarchy_changed_cb(GtkWidget* widget,
+                                 GtkWidget* previous_toplevel) {
+  GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
+  GdkWindowState old_window_state = GDK_WINDOW_STATE_WITHDRAWN;
+  GdkEventWindowState event;
+
+  event.new_window_state = GDK_WINDOW_STATE_WITHDRAWN;
+
+  if (GTK_IS_WINDOW(previous_toplevel)) {
+    g_signal_handlers_disconnect_by_func(
+        previous_toplevel, FuncToGpointer(window_state_event_cb), widget);
+    GdkWindow* win = gtk_widget_get_window(previous_toplevel);
+    if (win) {
+      old_window_state = gdk_window_get_state(win);
+    }
+  }
+
+  if (GTK_IS_WINDOW(toplevel)) {
+    g_signal_connect_swapped(toplevel, "window-state-event",
+                             G_CALLBACK(window_state_event_cb), widget);
+    GdkWindow* win = gtk_widget_get_window(toplevel);
+    if (win) {
+      event.new_window_state = gdk_window_get_state(win);
+    }
+  }
+
+  event.changed_mask =
+      static_cast<GdkWindowState>(old_window_state ^ event.new_window_state);
+
+  if (event.changed_mask) {
+    event.type = GDK_WINDOW_STATE;
+    event.window = nullptr;
+    event.send_event = TRUE;
+    window_state_event_cb(widget, &event);
+  }
+}
+
+static gboolean window_state_event_cb(GtkWidget* widget,
+                                      GdkEventWindowState* event) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) return FALSE;
+
+  window->OnWindowStateEvent(widget, event);
+
+  return FALSE;
+}
+
+static void settings_xft_dpi_changed_cb(GtkSettings* gtk_settings,
+                                        GParamSpec* pspec, nsWindow* data) {
+  RefPtr<nsWindow> window = data;
+  window->OnDPIChanged();
+  // Even though the window size in screen pixels has not changed,
+  // nsViewManager stores the dimensions in app units.
+  // DispatchResized() updates those.
+  window->DispatchResized();
+}
+
+static void check_resize_cb(GtkContainer* container, gpointer user_data) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(GTK_WIDGET(container));
+  if (!window) {
+    return;
+  }
+  window->OnCheckResize();
+}
+
+static void screen_composited_changed_cb(GdkScreen* screen,
+                                         gpointer user_data) {
+  // This callback can run before gfxPlatform::Init() in rare
+  // cases involving the profile manager. When this happens,
+  // we have no reason to reset any compositors as graphics
+  // hasn't been initialized yet.
+  if (GPUProcessManager::Get()) {
+    GPUProcessManager::Get()->ResetCompositors();
+  }
+}
+
+static void widget_composited_changed_cb(GtkWidget* widget,
+                                         gpointer user_data) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+  window->OnCompositedChanged();
+}
+
+static void scale_changed_cb(GtkWidget* widget, GParamSpec* aPSpec,
+                             gpointer aPointer) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+  if (!window) {
+    return;
+  }
+
+  window->OnScaleChanged();
+}
+
+static gboolean touch_event_cb(GtkWidget* aWidget, GdkEventTouch* aEvent) {
+  UpdateLastInputEventTime(aEvent);
+
+  RefPtr<nsWindow> window = GetFirstNSWindowForGDKWindow(aEvent->window);
+  if (!window) {
+    return FALSE;
+  }
+
+  return window->OnTouchEvent(aEvent);
+}
+
+// This function called generic because there is no signal specific to touchpad
+// pinch events.
+static gboolean generic_event_cb(GtkWidget* widget, GdkEvent* aEvent) {
+  if (aEvent->type != GDK_TOUCHPAD_PINCH) {
+    return FALSE;
+  }
+  // Using reinterpret_cast because the touchpad_pinch field of GdkEvent is not
+  // available in GTK+ versions lower than v3.18
+  GdkEventTouchpadPinch* event =
+      reinterpret_cast<GdkEventTouchpadPinch*>(aEvent);
+
+  RefPtr<nsWindow> window = GetFirstNSWindowForGDKWindow(event->window);
+
+  if (!window) {
+    return FALSE;
+  }
+  return window->OnTouchpadPinchEvent(event);
+}
+
+//////////////////////////////////////////////////////////////////////
+// These are all of our drag and drop operations
+
+void nsWindow::InitDragEvent(WidgetDragEvent& aEvent) {
+  // set the keyboard modifiers
+  guint modifierState = KeymapWrapper::GetCurrentModifierState();
+  KeymapWrapper::InitInputEvent(aEvent, modifierState);
+}
+
+static LayoutDeviceIntPoint GetWindowDropPosition(nsWindow* aWindow, int aX,
+                                                  int aY) {
+  // Workaround for Bug 1710344
+  // Caused by Gtk issue https://gitlab.gnome.org/GNOME/gtk/-/issues/4437
+  if (aWindow->IsWaylandPopup()) {
+    int tx = 0, ty = 0;
+    gdk_window_get_position(aWindow->GetToplevelGdkWindow(), &tx, &ty);
+    aX += tx;
+    aY += ty;
+  }
+  LOGDRAG("WindowDropPosition [%d, %d]", aX, aY);
+  return aWindow->GdkPointToDevicePixels({aX, aY});
+}
+
+gboolean WindowDragMotionHandler(GtkWidget* aWidget,
+                                 GdkDragContext* aDragContext, gint aX, gint aY,
+                                 guint aTime) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+  if (!window) {
+    return FALSE;
+  }
+
+  // figure out which internal widget this drag motion actually happened on
+  nscoord retx = 0;
+  nscoord rety = 0;
+
+  GdkWindow* innerWindow = get_inner_gdk_window(gtk_widget_get_window(aWidget),
+                                                aX, aY, &retx, &rety);
+  RefPtr<nsWindow> innerMostWindow = get_window_for_gdk_window(innerWindow);
+  if (!innerMostWindow) {
+    innerMostWindow = window;
+  }
+  LOGDRAG("WindowDragMotionHandler target nsWindow [%p]",
+          innerMostWindow.get());
+
+  RefPtr<nsDragService> dragService = nsDragService::GetInstance();
+  nsDragService::AutoEventLoop loop(dragService);
+  if (!dragService->ScheduleMotionEvent(
+          innerMostWindow, aDragContext,
+          GetWindowDropPosition(innerMostWindow, retx, rety), aTime)) {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+static gboolean drag_motion_event_cb(GtkWidget* aWidget,
+                                     GdkDragContext* aDragContext, gint aX,
+                                     gint aY, guint aTime, gpointer aData) {
+  return WindowDragMotionHandler(aWidget, aDragContext, aX, aY, aTime);
+}
+
+void WindowDragLeaveHandler(GtkWidget* aWidget) {
+  LOGDRAG("WindowDragLeaveHandler()\n");
+
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+  if (!window) {
+    LOGDRAG("    Failed - can't find nsWindow!\n");
+    return;
+  }
+
+  RefPtr<nsDragService> dragService = nsDragService::GetInstance();
+  nsDragService::AutoEventLoop loop(dragService);
+
+  nsWindow* mostRecentDragWindow = dragService->GetMostRecentDestWindow();
+  if (!mostRecentDragWindow) {
+    // This can happen when the target will not accept a drop.  A GTK drag
+    // source sends the leave message to the destination before the
+    // drag-failed signal on the source widget, but the leave message goes
+    // via the X server, and so doesn't get processed at least until the
+    // event loop runs again.
+    LOGDRAG("    Failed - GetMostRecentDestWindow()!\n");
+    return;
+  }
+
+  if (aWidget != window->GetGtkWidget()) {
+    // When the drag moves between widgets, GTK can send leave signal for
+    // the old widget after the motion or drop signal for the new widget.
+    // We'll send the leave event when the motion or drop event is run.
+    LOGDRAG("    Failed - GtkWidget mismatch!\n");
+    return;
+  }
+
+  LOGDRAG("WindowDragLeaveHandler nsWindow %p\n", (void*)mostRecentDragWindow);
+  dragService->ScheduleLeaveEvent();
+}
+
+static void drag_leave_event_cb(GtkWidget* aWidget,
+                                GdkDragContext* aDragContext, guint aTime,
+                                gpointer aData) {
+  WindowDragLeaveHandler(aWidget);
+}
+
+gboolean WindowDragDropHandler(GtkWidget* aWidget, GdkDragContext* aDragContext,
+                               gint aX, gint aY, guint aTime) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+  if (!window) return FALSE;
+
+  // figure out which internal widget this drag motion actually happened on
+  nscoord retx = 0;
+  nscoord rety = 0;
+
+  GdkWindow* innerWindow = get_inner_gdk_window(gtk_widget_get_window(aWidget),
+                                                aX, aY, &retx, &rety);
+  RefPtr<nsWindow> innerMostWindow = get_window_for_gdk_window(innerWindow);
+
+  if (!innerMostWindow) {
+    innerMostWindow = window;
+  }
+
+  LOGDRAG("WindowDragDropHandler nsWindow [%p]", innerMostWindow.get());
+  RefPtr<nsDragService> dragService = nsDragService::GetInstance();
+  nsDragService::AutoEventLoop loop(dragService);
+  return dragService->ScheduleDropEvent(
+      innerMostWindow, aDragContext,
+      GetWindowDropPosition(innerMostWindow, retx, rety), aTime);
+}
+
+static gboolean drag_drop_event_cb(GtkWidget* aWidget,
+                                   GdkDragContext* aDragContext, gint aX,
+                                   gint aY, guint aTime, gpointer aData) {
+  return WindowDragDropHandler(aWidget, aDragContext, aX, aY, aTime);
+}
+
+static void drag_data_received_event_cb(GtkWidget* aWidget,
+                                        GdkDragContext* aDragContext, gint aX,
+                                        gint aY,
+                                        GtkSelectionData* aSelectionData,
+                                        guint aInfo, guint aTime,
+                                        gpointer aData) {
+  RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+  if (!window) return;
+
+  window->OnDragDataReceivedEvent(aWidget, aDragContext, aX, aY, aSelectionData,
+                                  aInfo, aTime, aData);
+}
+
+static nsresult initialize_prefs(void) {
+  if (Preferences::HasUserValue("widget.use-aspect-ratio")) {
+    gUseAspectRatio = Preferences::GetBool("widget.use-aspect-ratio", true);
+  } else {
+    gUseAspectRatio = IsGnomeDesktopEnvironment();
+  }
+
+  return NS_OK;
+}
+
+// TODO: Can we simplify it for mShell/mContainer only scenario?
+static GdkWindow* get_inner_gdk_window(GdkWindow* aWindow, gint x, gint y,
+                                       gint* retx, gint* rety) {
+  gint cx, cy, cw, ch;
+  GList* children = gdk_window_peek_children(aWindow);
+  for (GList* child = g_list_last(children); child;
+       child = g_list_previous(child)) {
+    auto* childWindow = (GdkWindow*)child->data;
+    if (get_window_for_gdk_window(childWindow)) {
+      gdk_window_get_geometry(childWindow, &cx, &cy, &cw, &ch);
+      if ((cx < x) && (x < (cx + cw)) && (cy < y) && (y < (cy + ch)) &&
+          gdk_window_is_visible(childWindow)) {
+        return get_inner_gdk_window(childWindow, x - cx, y - cy, retx, rety);
+      }
+    }
+  }
+  *retx = x;
+  *rety = y;
+  return aWindow;
+}
+
+#ifdef ACCESSIBILITY
+void nsWindow::CreateRootAccessible() {
+  if (!mRootAccessible) {
+    LOG("nsWindow:: Create Toplevel Accessibility\n");
+    mRootAccessible = GetRootAccessible();
+  }
+}
+
+void nsWindow::DispatchEventToRootAccessible(uint32_t aEventType) {
+  if (!a11y::ShouldA11yBeEnabled()) {
+    return;
+  }
+
+  nsAccessibilityService* accService = GetOrCreateAccService();
+  if (!accService) {
+    return;
+  }
+
+  // Get the root document accessible and fire event to it.
+  a11y::LocalAccessible* acc = GetRootAccessible();
+  if (acc) {
+    accService->FireAccessibleEvent(aEventType, acc);
+  }
+}
+
+void nsWindow::DispatchActivateEventAccessible(void) {
+  DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_ACTIVATE);
+}
+
+void nsWindow::DispatchDeactivateEventAccessible(void) {
+  DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_DEACTIVATE);
+}
+
+void nsWindow::DispatchMaximizeEventAccessible(void) {
+  DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_MAXIMIZE);
+}
+
+void nsWindow::DispatchMinimizeEventAccessible(void) {
+  DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_MINIMIZE);
+}
+
+void nsWindow::DispatchRestoreEventAccessible(void) {
+  DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_RESTORE);
+}
+
+#endif /* #ifdef ACCESSIBILITY */
+
+void nsWindow::SetInputContext(const InputContext& aContext,
+                               const InputContextAction& aAction) {
+  if (!mIMContext) {
+    return;
+  }
+  mIMContext->SetInputContext(this, &aContext, &aAction);
+}
+
+InputContext nsWindow::GetInputContext() {
+  InputContext context;
+  if (!mIMContext) {
+    context.mIMEState.mEnabled = IMEEnabled::Disabled;
+    context.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED;
+  } else {
+    context = mIMContext->GetInputContext();
+  }
+  return context;
+}
+
+TextEventDispatcherListener* nsWindow::GetNativeTextEventDispatcherListener() {
+  if (NS_WARN_IF(!mIMContext)) {
+    return nullptr;
+  }
+  return mIMContext;
+}
+
+bool nsWindow::GetEditCommands(NativeKeyBindingsType aType,
+                               const WidgetKeyboardEvent& aEvent,
+                               nsTArray<CommandInt>& aCommands) {
+  // Validate the arguments.
+  if (NS_WARN_IF(!nsIWidget::GetEditCommands(aType, aEvent, aCommands))) {
+    return false;
+  }
+
+  Maybe<WritingMode> writingMode;
+  if (aEvent.NeedsToRemapNavigationKey()) {
+    if (RefPtr<TextEventDispatcher> dispatcher = GetTextEventDispatcher()) {
+      writingMode = dispatcher->MaybeQueryWritingModeAtSelection();
+    }
+  }
+
+  NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType);
+  keyBindings->GetEditCommands(aEvent, writingMode, aCommands);
+  return true;
+}
+
+already_AddRefed<DrawTarget> nsWindow::StartRemoteDrawingInRegion(
+    const LayoutDeviceIntRegion& aInvalidRegion, BufferMode* aBufferMode) {
+  return mSurfaceProvider.StartRemoteDrawingInRegion(aInvalidRegion,
+                                                     aBufferMode);
+}
+
+void nsWindow::EndRemoteDrawingInRegion(
+    DrawTarget* aDrawTarget, const LayoutDeviceIntRegion& aInvalidRegion) {
+  mSurfaceProvider.EndRemoteDrawingInRegion(aDrawTarget, aInvalidRegion);
+}
+
+bool nsWindow::GetDragInfo(WidgetMouseEvent* aMouseEvent, GdkWindow** aWindow,
+                           gint* aButton, gint* aRootX, gint* aRootY) {
+  if (aMouseEvent->mButton != MouseButton::ePrimary) {
+    // we can only begin a move drag with the left mouse button
+    return false;
+  }
+  *aButton = 1;
+
+  // get the gdk window for this widget
+  GdkWindow* gdk_window = mGdkWindow;
+  if (!gdk_window) {
+    return false;
+  }
+#ifdef DEBUG
+  // GDK_IS_WINDOW(...) expands to a statement-expression, and
+  // statement-expressions are not allowed in template-argument lists. So we
+  // have to make the MOZ_ASSERT condition indirect.
+  if (!GDK_IS_WINDOW(gdk_window)) {
+    MOZ_ASSERT(false, "must really be window");
+  }
+#endif
+
+  // find the top-level window
+  gdk_window = gdk_window_get_toplevel(gdk_window);
+  MOZ_ASSERT(gdk_window, "gdk_window_get_toplevel should not return null");
+  *aWindow = gdk_window;
+
+  if (!aMouseEvent->mWidget) {
+    return false;
+  }
+
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    // Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=789054
+    // To avoid crashes disable double-click on WM without _NET_WM_MOVERESIZE.
+    // See _should_perform_ewmh_drag() at gdkwindow-x11.c
+    // XXXsmaug remove this old hack. gtk should be fixed now.
+    GdkScreen* screen = gdk_window_get_screen(gdk_window);
+    GdkAtom atom = gdk_atom_intern("_NET_WM_MOVERESIZE", FALSE);
+    if (!gdk_x11_screen_supports_net_wm_hint(screen, atom)) {
+      static TimeStamp lastTimeStamp;
+      if (lastTimeStamp != aMouseEvent->mTimeStamp) {
+        lastTimeStamp = aMouseEvent->mTimeStamp;
+      } else {
+        return false;
+      }
+    }
+  }
+#endif
+
+  // FIXME: It would be nice to have the widget position at the time
+  // of the event, but it's relatively unlikely that the widget has
+  // moved since the mousedown.  (On the other hand, it's quite likely
+  // that the mouse has moved, which is why we use the mouse position
+  // from the event.)
+  LayoutDeviceIntPoint offset = aMouseEvent->mWidget->WidgetToScreenOffset();
+  *aRootX = aMouseEvent->mRefPoint.x + offset.x;
+  *aRootY = aMouseEvent->mRefPoint.y + offset.y;
+
+  return true;
+}
+
+nsIWidget::WindowRenderer* nsWindow::GetWindowRenderer() {
+  if (mIsDestroyed) {
+    // Prevent external code from triggering the re-creation of the
+    // LayerManager/Compositor during shutdown. Just return what we currently
+    // have, which is most likely null.
+    return mWindowRenderer;
+  }
+
+  return nsBaseWidget::GetWindowRenderer();
+}
+
+void nsWindow::DidGetNonBlankPaint() {
+  if (mGotNonBlankPaint) {
+    return;
+  }
+  mGotNonBlankPaint = true;
+  if (!mConfiguredClearColor) {
+    // Nothing to do, we hadn't overridden the clear color.
+    mConfiguredClearColor = true;
+    return;
+  }
+  // Reset the clear color set in the expose event to transparent.
+  GetWindowRenderer()->AsWebRender()->WrBridge()->SendSetDefaultClearColor(
+      NS_TRANSPARENT);
+}
+
+/* nsWindow::SetCompositorWidgetDelegate() sets remote GtkCompositorWidget
+ * to render into with compositor.
+ *
+ * SetCompositorWidgetDelegate(delegate) is called from
+ * nsBaseWidget::CreateCompositor(), i.e. nsWindow::GetWindowRenderer().
+ *
+ * SetCompositorWidgetDelegate(null) is called from
+ * nsBaseWidget::DestroyCompositor().
+ */
+void nsWindow::SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) {
+  LOG("nsWindow::SetCompositorWidgetDelegate %p mIsMapped %d "
+      "mCompositorWidgetDelegate %p\n",
+      delegate, mIsMapped, mCompositorWidgetDelegate);
+
+  if (delegate) {
+    mCompositorWidgetDelegate = delegate->AsPlatformSpecificDelegate();
+    MOZ_ASSERT(mCompositorWidgetDelegate,
+               "nsWindow::SetCompositorWidgetDelegate called with a "
+               "non-PlatformCompositorWidgetDelegate");
+    if (mIsMapped) {
+      ConfigureCompositor();
+    }
+  } else {
+    mCompositorWidgetDelegate = nullptr;
+  }
+}
+
+nsresult nsWindow::SetNonClientMargins(LayoutDeviceIntMargin& aMargins) {
+  SetDrawsInTitlebar(aMargins.top == 0);
+  return NS_OK;
+}
+
+void nsWindow::SetDrawsInTitlebar(bool aState) {
+  LOG("nsWindow::SetDrawsInTitlebar() State %d mGtkWindowDecoration %d\n",
+      aState, (int)mGtkWindowDecoration);
+
+  if (mGtkWindowDecoration == GTK_DECORATION_NONE ||
+      aState == mDrawInTitlebar) {
+    LOG("  already set, quit");
+    return;
+  }
+
+  if (mIsPIPWindow) {
+    gtk_window_set_decorated(GTK_WINDOW(mShell), !aState);
+    LOG("  set decoration for PIP %d", aState);
+    return;
+  }
+
+  if (mGtkWindowDecoration == GTK_DECORATION_SYSTEM) {
+    SetWindowDecoration(aState ? eBorderStyle_border : mBorderStyle);
+  } else if (mGtkWindowDecoration == GTK_DECORATION_CLIENT) {
+    LOG("    Using CSD mode\n");
+
+    /* Window manager does not support GDK_DECOR_BORDER,
+     * emulate it by CSD.
+     *
+     * gtk_window_set_titlebar() works on unrealized widgets only,
+     * we need to handle mShell carefully here.
+     * When CSD is enabled mGdkWindow is owned by mContainer which is good
+     * as we can't delete our mGdkWindow. To make mShell unrealized while
+     * mContainer is preserved we temporary reparent mContainer to an
+     * invisible GtkWindow.
+     */
+    bool visible = !mNeedsShow && mIsShown;
+    if (visible) {
+      NativeShow(false);
+    }
+
+    // Using GTK_WINDOW_POPUP rather than
+    // GTK_WINDOW_TOPLEVEL in the hope that POPUP results in less
+    // initialization and window manager interaction.
+    GtkWidget* tmpWindow = gtk_window_new(GTK_WINDOW_POPUP);
+    gtk_widget_realize(tmpWindow);
+
+    gtk_widget_reparent(GTK_WIDGET(mContainer), tmpWindow);
+    gtk_widget_unrealize(GTK_WIDGET(mShell));
+
+    if (aState) {
+      // Add a hidden titlebar widget to trigger CSD, but disable the default
+      // titlebar.  GtkFixed is a somewhat random choice for a simple unused
+      // widget. gtk_window_set_titlebar() takes ownership of the titlebar
+      // widget.
+      gtk_window_set_titlebar(GTK_WINDOW(mShell), gtk_fixed_new());
+    } else {
+      gtk_window_set_titlebar(GTK_WINDOW(mShell), nullptr);
+    }
+
+    /* A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=791081
+     * gtk_widget_realize() throws:
+     * "In pixman_region32_init_rect: Invalid rectangle passed"
+     * when mShell has default 1x1 size.
+     */
+    GtkAllocation allocation = {0, 0, 0, 0};
+    gtk_widget_get_preferred_width(GTK_WIDGET(mShell), nullptr,
+                                   &allocation.width);
+    gtk_widget_get_preferred_height(GTK_WIDGET(mShell), nullptr,
+                                    &allocation.height);
+    gtk_widget_size_allocate(GTK_WIDGET(mShell), &allocation);
+
+    gtk_widget_realize(GTK_WIDGET(mShell));
+    gtk_widget_reparent(GTK_WIDGET(mContainer), GTK_WIDGET(mShell));
+
+    // Label mShell toplevel window so property_notify_event_cb callback
+    // can find its way home.
+    g_object_set_data(G_OBJECT(gtk_widget_get_window(mShell)), "nsWindow",
+                      this);
+
+    if (AreBoundsSane()) {
+      GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mBounds.Size());
+      LOG("    resize to %d x %d\n", size.width, size.height);
+      gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height);
+    }
+
+    if (visible) {
+      mNeedsShow = true;
+      NativeShow(true);
+    }
+
+    gtk_widget_destroy(tmpWindow);
+  }
+
+  mDrawInTitlebar = aState;
+
+  if (mTransparencyBitmapForTitlebar) {
+    if (mDrawInTitlebar && mSizeMode == nsSizeMode_Normal && !mIsTiled) {
+      UpdateTitlebarTransparencyBitmap();
+    } else {
+      ClearTransparencyBitmap();
+    }
+  }
+}
+
+GtkWindow* nsWindow::GetCurrentTopmostWindow() const {
+  GtkWindow* parentWindow = GTK_WINDOW(GetGtkWidget());
+  GtkWindow* topmostParentWindow = nullptr;
+  while (parentWindow) {
+    topmostParentWindow = parentWindow;
+    parentWindow = gtk_window_get_transient_for(parentWindow);
+  }
+  return topmostParentWindow;
+}
+
+gint nsWindow::GdkCeiledScaleFactor() {
+  // We depend on notify::scale-factor callback which is reliable for toplevel
+  // windows only, so don't use scale cache for popup windows.
+  if (mWindowType == eWindowType_toplevel && !mWindowScaleFactorChanged) {
+    return mWindowScaleFactor;
+  }
+
+  GdkWindow* scaledGdkWindow = nullptr;
+  if (GdkIsWaylandDisplay()) {
+    // For popup windows/dialogs with parent window we need to get scale factor
+    // of the topmost window. Otherwise the scale factor of the popup is
+    // not updated during it's hidden.
+    if (mWindowType == eWindowType_popup || mWindowType == eWindowType_dialog) {
+      // Get toplevel window for scale factor:
+      GtkWindow* topmostParentWindow = GetCurrentTopmostWindow();
+      if (topmostParentWindow) {
+        scaledGdkWindow =
+            gtk_widget_get_window(GTK_WIDGET(topmostParentWindow));
+      } else {
+        NS_WARNING("Popup/Dialog has no parent.");
+      }
+    }
+  }
+  // Fallback for windows which parent has been unrealized.
+  if (!scaledGdkWindow) {
+    scaledGdkWindow = mGdkWindow;
+  }
+  if (scaledGdkWindow) {
+    mWindowScaleFactor = gdk_window_get_scale_factor(scaledGdkWindow);
+    mWindowScaleFactorChanged = false;
+  } else {
+    mWindowScaleFactor = ScreenHelperGTK::GetGTKMonitorScaleFactor();
+  }
+  return mWindowScaleFactor;
+}
+
+bool nsWindow::UseFractionalScale() const {
+#ifdef MOZ_WAYLAND
+  return GdkIsWaylandDisplay() &&
+         StaticPrefs::widget_wayland_fractional_buffer_scale_AtStartup() > 0 &&
+         WaylandDisplayGet()->GetViewporter();
+#else
+  return false;
+#endif
+}
+
+double nsWindow::FractionalScaleFactor() {
+#ifdef MOZ_WAYLAND
+  if (UseFractionalScale()) {
+    double scale =
+        StaticPrefs::widget_wayland_fractional_buffer_scale_AtStartup();
+    scale = std::max(scale, 0.5);
+    scale = std::min(scale, 8.0);
+    return scale;
+  }
+#endif
+  return GdkCeiledScaleFactor();
+}
+
+gint nsWindow::DevicePixelsToGdkCoordRoundUp(int aPixels) {
+  double scale = FractionalScaleFactor();
+  return ceil(aPixels / scale);
+}
+
+gint nsWindow::DevicePixelsToGdkCoordRoundDown(int aPixels) {
+  double scale = FractionalScaleFactor();
+  return floor(aPixels / scale);
+}
+
+GdkPoint nsWindow::DevicePixelsToGdkPointRoundDown(
+    const LayoutDeviceIntPoint& aPoint) {
+  double scale = FractionalScaleFactor();
+  return {int(aPoint.x / scale), int(aPoint.y / scale)};
+}
+
+GdkRectangle nsWindow::DevicePixelsToGdkRectRoundOut(
+    const LayoutDeviceIntRect& aRect) {
+  double scale = FractionalScaleFactor();
+  int x = floor(aRect.x / scale);
+  int y = floor(aRect.y / scale);
+  int right = ceil((aRect.x + aRect.width) / scale);
+  int bottom = ceil((aRect.y + aRect.height) / scale);
+  return {x, y, right - x, bottom - y};
+}
+
+GdkRectangle nsWindow::DevicePixelsToGdkSizeRoundUp(
+    const LayoutDeviceIntSize& aSize) {
+  double scale = FractionalScaleFactor();
+  gint width = ceil(aSize.width / scale);
+  gint height = ceil(aSize.height / scale);
+  return {0, 0, width, height};
+}
+
+int nsWindow::GdkCoordToDevicePixels(gint aCoord) {
+  return (int)(aCoord * FractionalScaleFactor());
+}
+
+LayoutDeviceIntPoint nsWindow::GdkEventCoordsToDevicePixels(gdouble aX,
+                                                            gdouble aY) {
+  double scale = FractionalScaleFactor();
+  return LayoutDeviceIntPoint::Floor((float)(aX * scale), (float)(aY * scale));
+}
+
+LayoutDeviceIntPoint nsWindow::GdkPointToDevicePixels(const GdkPoint& aPoint) {
+  double scale = FractionalScaleFactor();
+  return LayoutDeviceIntPoint::Floor((float)(aPoint.x * scale),
+                                     (float)(aPoint.y * scale));
+}
+
+LayoutDeviceIntRect nsWindow::GdkRectToDevicePixels(const GdkRectangle& aRect) {
+  double scale = FractionalScaleFactor();
+  return LayoutDeviceIntRect::RoundIn(
+      (float)(aRect.x * scale), (float)(aRect.y * scale),
+      (float)(aRect.width * scale), (float)(aRect.height * scale));
+}
+
+nsresult nsWindow::SynthesizeNativeMouseEvent(
+    LayoutDeviceIntPoint aPoint, NativeMouseMessage aNativeMessage,
+    MouseButton aButton, nsIWidget::Modifiers aModifierFlags,
+    nsIObserver* aObserver) {
+  LOG("SynthesizeNativeMouseEvent(%d, %d, %d, %d, %d)", aPoint.x.value,
+      aPoint.y.value, int(aNativeMessage), int(aButton), int(aModifierFlags));
+
+  AutoObserverNotifier notifier(aObserver, "mouseevent");
+
+  if (!mGdkWindow) {
+    return NS_OK;
+  }
+
+  // When a button-press/release event is requested, create it here and put it
+  // in the event queue. This will not emit a motion event - this needs to be
+  // done explicitly *before* requesting a button-press/release. You will also
+  // need to wait for the motion event to be dispatched before requesting a
+  // button-press/release event to maintain the desired event order.
+  switch (aNativeMessage) {
+    case NativeMouseMessage::ButtonDown:
+    case NativeMouseMessage::ButtonUp: {
+      GdkEvent event;
+      memset(&event, 0, sizeof(GdkEvent));
+      event.type = aNativeMessage == NativeMouseMessage::ButtonDown
+                       ? GDK_BUTTON_PRESS
+                       : GDK_BUTTON_RELEASE;
+      switch (aButton) {
+        case MouseButton::ePrimary:
+        case MouseButton::eMiddle:
+        case MouseButton::eSecondary:
+        case MouseButton::eX1:
+        case MouseButton::eX2:
+          event.button.button = aButton + 1;
+          break;
+        default:
+          return NS_ERROR_INVALID_ARG;
+      }
+      event.button.state =
+          KeymapWrapper::ConvertWidgetModifierToGdkState(aModifierFlags);
+      event.button.window = mGdkWindow;
+      event.button.time = GDK_CURRENT_TIME;
+
+      // Get device for event source
+      event.button.device = GdkGetPointer();
+
+      event.button.x_root = DevicePixelsToGdkCoordRoundDown(aPoint.x);
+      event.button.y_root = DevicePixelsToGdkCoordRoundDown(aPoint.y);
+
+      LayoutDeviceIntPoint pointInWindow = aPoint - WidgetToScreenOffset();
+      event.button.x = DevicePixelsToGdkCoordRoundDown(pointInWindow.x);
+      event.button.y = DevicePixelsToGdkCoordRoundDown(pointInWindow.y);
+
+      gdk_event_put(&event);
+      return NS_OK;
+    }
+    case NativeMouseMessage::Move: {
+      // We don't support specific events other than button-press/release. In
+      // all other cases we'll synthesize a motion event that will be emitted by
+      // gdk_display_warp_pointer().
+      // XXX How to activate native modifier for the other events?
+#ifdef MOZ_WAYLAND
+      // Impossible to warp the pointer on Wayland.
+      // For pointer lock, pointer-constraints and relative-pointer are used.
+      if (GdkIsWaylandDisplay()) {
+        return NS_OK;
+      }
+#endif
+      GdkScreen* screen = gdk_window_get_screen(mGdkWindow);
+      GdkPoint point = DevicePixelsToGdkPointRoundDown(aPoint);
+      gdk_device_warp(GdkGetPointer(), screen, point.x, point.y);
+      return NS_OK;
+    }
+    case NativeMouseMessage::EnterWindow:
+    case NativeMouseMessage::LeaveWindow:
+      MOZ_ASSERT_UNREACHABLE("Non supported mouse event on Linux");
+      return NS_ERROR_INVALID_ARG;
+  }
+  return NS_ERROR_UNEXPECTED;
+}
+
+void nsWindow::CreateAndPutGdkScrollEvent(mozilla::LayoutDeviceIntPoint aPoint,
+                                          double aDeltaX, double aDeltaY) {
+  GdkEvent event;
+  memset(&event, 0, sizeof(GdkEvent));
+  event.type = GDK_SCROLL;
+  event.scroll.window = mGdkWindow;
+  event.scroll.time = GDK_CURRENT_TIME;
+  // Get device for event source
+  GdkDisplay* display = gdk_window_get_display(mGdkWindow);
+  GdkDeviceManager* device_manager = gdk_display_get_device_manager(display);
+  // See note in nsWindow::SynthesizeNativeTouchpadPan about the device we use
+  // here.
+  event.scroll.device = gdk_device_manager_get_client_pointer(device_manager);
+  event.scroll.x_root = DevicePixelsToGdkCoordRoundDown(aPoint.x);
+  event.scroll.y_root = DevicePixelsToGdkCoordRoundDown(aPoint.y);
+
+  LayoutDeviceIntPoint pointInWindow = aPoint - WidgetToScreenOffset();
+  event.scroll.x = DevicePixelsToGdkCoordRoundDown(pointInWindow.x);
+  event.scroll.y = DevicePixelsToGdkCoordRoundDown(pointInWindow.y);
+
+  // The delta values are backwards on Linux compared to Windows and Cocoa,
+  // hence the negation.
+  event.scroll.direction = GDK_SCROLL_SMOOTH;
+  event.scroll.delta_x = -aDeltaX;
+  event.scroll.delta_y = -aDeltaY;
+
+  gdk_event_put(&event);
+}
+
+nsresult nsWindow::SynthesizeNativeMouseScrollEvent(
+    mozilla::LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage,
+    double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aModifierFlags,
+    uint32_t aAdditionalFlags, nsIObserver* aObserver) {
+  AutoObserverNotifier notifier(aObserver, "mousescrollevent");
+
+  if (!mGdkWindow) {
+    return NS_OK;
+  }
+
+  CreateAndPutGdkScrollEvent(aPoint, aDeltaX, aDeltaY);
+
+  return NS_OK;
+}
+
+nsresult nsWindow::SynthesizeNativeTouchPoint(uint32_t aPointerId,
+                                              TouchPointerState aPointerState,
+                                              LayoutDeviceIntPoint aPoint,
+                                              double aPointerPressure,
+                                              uint32_t aPointerOrientation,
+                                              nsIObserver* aObserver) {
+  AutoObserverNotifier notifier(aObserver, "touchpoint");
+
+  if (!mGdkWindow) {
+    return NS_OK;
+  }
+
+  GdkEvent event;
+  memset(&event, 0, sizeof(GdkEvent));
+
+  static std::map<uint32_t, GdkEventSequence*> sKnownPointers;
+
+  auto result = sKnownPointers.find(aPointerId);
+  switch (aPointerState) {
+    case TOUCH_CONTACT:
+      if (result == sKnownPointers.end()) {
+        // GdkEventSequence isn't a thing we can instantiate, and never gets
+        // dereferenced in the gtk code. It's an opaque pointer, the only
+        // requirement is that it be distinct from other instances of
+        // GdkEventSequence*.
+        event.touch.sequence = (GdkEventSequence*)((uintptr_t)aPointerId);
+        sKnownPointers[aPointerId] = event.touch.sequence;
+        event.type = GDK_TOUCH_BEGIN;
+      } else {
+        event.touch.sequence = result->second;
+        event.type = GDK_TOUCH_UPDATE;
+      }
+      break;
+    case TOUCH_REMOVE:
+      event.type = GDK_TOUCH_END;
+      if (result == sKnownPointers.end()) {
+        NS_WARNING("Tried to synthesize touch-end for unknown pointer!");
+        return NS_ERROR_UNEXPECTED;
+      }
+      event.touch.sequence = result->second;
+      sKnownPointers.erase(result);
+      break;
+    case TOUCH_CANCEL:
+      event.type = GDK_TOUCH_CANCEL;
+      if (result == sKnownPointers.end()) {
+        NS_WARNING("Tried to synthesize touch-cancel for unknown pointer!");
+        return NS_ERROR_UNEXPECTED;
+      }
+      event.touch.sequence = result->second;
+      sKnownPointers.erase(result);
+      break;
+    case TOUCH_HOVER:
+    default:
+      return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  event.touch.window = mGdkWindow;
+  event.touch.time = GDK_CURRENT_TIME;
+
+  GdkDisplay* display = gdk_window_get_display(mGdkWindow);
+  GdkDeviceManager* device_manager = gdk_display_get_device_manager(display);
+  event.touch.device = gdk_device_manager_get_client_pointer(device_manager);
+
+  event.touch.x_root = DevicePixelsToGdkCoordRoundDown(aPoint.x);
+  event.touch.y_root = DevicePixelsToGdkCoordRoundDown(aPoint.y);
+
+  LayoutDeviceIntPoint pointInWindow = aPoint - WidgetToScreenOffset();
+  event.touch.x = DevicePixelsToGdkCoordRoundDown(pointInWindow.x);
+  event.touch.y = DevicePixelsToGdkCoordRoundDown(pointInWindow.y);
+
+  gdk_event_put(&event);
+
+  return NS_OK;
+}
+
+nsresult nsWindow::SynthesizeNativeTouchPadPinch(
+    TouchpadGesturePhase aEventPhase, float aScale, LayoutDeviceIntPoint aPoint,
+    int32_t aModifierFlags) {
+  if (!mGdkWindow) {
+    return NS_OK;
+  }
+  GdkEvent event;
+  memset(&event, 0, sizeof(GdkEvent));
+
+  GdkEventTouchpadPinch* touchpad_event =
+      reinterpret_cast<GdkEventTouchpadPinch*>(&event);
+  touchpad_event->type = GDK_TOUCHPAD_PINCH;
+
+  const ScreenIntPoint widgetToScreenOffset = ViewAs<ScreenPixel>(
+      WidgetToScreenOffset(),
+      PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
+
+  ScreenPoint pointInWindow =
+      ViewAs<ScreenPixel>(
+          aPoint,
+          PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent) -
+      widgetToScreenOffset;
+
+  gdouble dx = 0, dy = 0;
+
+  switch (aEventPhase) {
+    case PHASE_BEGIN:
+      touchpad_event->phase = GDK_TOUCHPAD_GESTURE_PHASE_BEGIN;
+      mCurrentSynthesizedTouchpadPinch = {pointInWindow, pointInWindow};
+      break;
+    case PHASE_UPDATE:
+      dx = pointInWindow.x - mCurrentSynthesizedTouchpadPinch.mCurrentFocus.x;
+      dy = pointInWindow.y - mCurrentSynthesizedTouchpadPinch.mCurrentFocus.y;
+      mCurrentSynthesizedTouchpadPinch.mCurrentFocus = pointInWindow;
+      touchpad_event->phase = GDK_TOUCHPAD_GESTURE_PHASE_UPDATE;
+      break;
+    case PHASE_END:
+      touchpad_event->phase = GDK_TOUCHPAD_GESTURE_PHASE_END;
+      break;
+
+    default:
+      return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  touchpad_event->window = mGdkWindow;
+  // We only set the fields of GdkEventTouchpadPinch which are
+  // actually used in OnTouchpadPinchEvent().
+  // GdkEventTouchpadPinch has additional fields.
+  // If OnTouchpadPinchEvent() is changed to use other fields, this function
+  // will need to change to set them as well.
+  touchpad_event->time = GDK_CURRENT_TIME;
+  touchpad_event->scale = aScale;
+  touchpad_event->x_root = DevicePixelsToGdkCoordRoundDown(
+      mCurrentSynthesizedTouchpadPinch.mBeginFocus.x +
+      ScreenCoord(widgetToScreenOffset.x));
+  touchpad_event->y_root = DevicePixelsToGdkCoordRoundDown(
+      mCurrentSynthesizedTouchpadPinch.mBeginFocus.y +
+      ScreenCoord(widgetToScreenOffset.y));
+
+  touchpad_event->x = DevicePixelsToGdkCoordRoundDown(
+      mCurrentSynthesizedTouchpadPinch.mBeginFocus.x);
+  touchpad_event->y = DevicePixelsToGdkCoordRoundDown(
+      mCurrentSynthesizedTouchpadPinch.mBeginFocus.y);
+
+  touchpad_event->dx = dx;
+  touchpad_event->dy = dy;
+
+  touchpad_event->state = aModifierFlags;
+
+  gdk_event_put(&event);
+
+  return NS_OK;
+}
+
+nsresult nsWindow::SynthesizeNativeTouchpadPan(TouchpadGesturePhase aEventPhase,
+                                               LayoutDeviceIntPoint aPoint,
+                                               double aDeltaX, double aDeltaY,
+                                               int32_t aModifierFlags,
+                                               nsIObserver* aObserver) {
+  AutoObserverNotifier notifier(aObserver, "touchpadpanevent");
+
+  if (!mGdkWindow) {
+    return NS_OK;
+  }
+
+  // This should/could maybe send GdkEventTouchpadSwipe events, however we don't
+  // currently consume those (either real user input or testing events). So we
+  // send gdk scroll events to be more like what we do for real user input. If
+  // we start consuming GdkEventTouchpadSwipe and get those hooked up to swipe
+  // to nav, then maybe we should test those too.
+
+  mCurrentSynthesizedTouchpadPan.mTouchpadGesturePhase = Some(aEventPhase);
+  MOZ_ASSERT(mCurrentSynthesizedTouchpadPan.mSavedObserver == 0);
+  mCurrentSynthesizedTouchpadPan.mSavedObserver = notifier.SaveObserver();
+
+  // Note that CreateAndPutGdkScrollEvent sets the device source for the created
+  // event as the "client pointer" (a kind of default device) which will
+  // probably be of type mouse. We would ideally want to set the device of the
+  // created event to be a touchpad, but the system might not have a touchpad.
+  // To get around this we use
+  // mCurrentSynthesizedTouchpadPan.mTouchpadGesturePhase being something to
+  // indicate that we should treat the source of the event as touchpad in
+  // OnScrollEvent.
+  CreateAndPutGdkScrollEvent(aPoint, aDeltaX, aDeltaY);
+
+  return NS_OK;
+}
+
+nsWindow::GtkWindowDecoration nsWindow::GetSystemGtkWindowDecoration() {
+  static GtkWindowDecoration sGtkWindowDecoration = [] {
+    // Allow MOZ_GTK_TITLEBAR_DECORATION to override our heuristics
+    if (const char* decorationOverride =
+            getenv("MOZ_GTK_TITLEBAR_DECORATION")) {
+      if (strcmp(decorationOverride, "none") == 0) {
+        return GTK_DECORATION_NONE;
+      }
+      if (strcmp(decorationOverride, "client") == 0) {
+        return GTK_DECORATION_CLIENT;
+      }
+      if (strcmp(decorationOverride, "system") == 0) {
+        return GTK_DECORATION_SYSTEM;
+      }
+    }
+
+    // nsWindow::GetSystemGtkWindowDecoration can be called from various
+    // threads so we can't use gfxPlatformGtk here.
+    if (GdkIsWaylandDisplay()) {
+      return GTK_DECORATION_CLIENT;
+    }
+
+    // GTK_CSD forces CSD mode - use also CSD because window manager
+    // decorations does not work with CSD.
+    // We check GTK_CSD as well as gtk_window_should_use_csd() does.
+    const char* csdOverride = getenv("GTK_CSD");
+    if (csdOverride && *csdOverride == '1') {
+      return GTK_DECORATION_CLIENT;
+    }
+
+    // TODO: Consider switching this to GetDesktopEnvironmentIdentifier().
+    const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP");
+    if (!currentDesktop) {
+      return GTK_DECORATION_NONE;
+    }
+    if (strstr(currentDesktop, "i3")) {
+      return GTK_DECORATION_NONE;
+    }
+
+    // Tested desktops: pop:GNOME, KDE, Enlightenment, LXDE, openbox, MATE,
+    // X-Cinnamon, Pantheon, Deepin, GNOME, LXQt, Unity.
+    return GTK_DECORATION_CLIENT;
+  }();
+  return sGtkWindowDecoration;
+}
+
+bool nsWindow::TitlebarUseShapeMask() {
+  static int useShapeMask = []() {
+    // Don't use titlebar shape mask on Wayland
+    if (!GdkIsX11Display()) {
+      return false;
+    }
+
+    // We can't use shape masks on Mutter/X.org as we can't resize Firefox
+    // window there (Bug 1530252).
+    if (IsGnomeDesktopEnvironment()) {
+      return false;
+    }
+
+    return Preferences::GetBool("widget.titlebar-x11-use-shape-mask", false);
+  }();
+  return useShapeMask;
+}
+
+int32_t nsWindow::RoundsWidgetCoordinatesTo() { return GdkCeiledScaleFactor(); }
+
+void nsWindow::GetCompositorWidgetInitData(
+    mozilla::widget::CompositorWidgetInitData* aInitData) {
+  nsCString displayName;
+
+  LOG("nsWindow::GetCompositorWidgetInitData");
+  EnsureGdkWindow();
+
+  *aInitData = mozilla::widget::GtkCompositorWidgetInitData(
+      GetX11Window(), displayName, GetShapedState(), GdkIsX11Display(),
+      GetClientSize());
+
+#ifdef MOZ_X11
+  if (GdkIsX11Display()) {
+    // Make sure the window XID is propagated to X server, we can fail otherwise
+    // in GPU process (Bug 1401634).
+    Display* display = DefaultXDisplay();
+    XFlush(display);
+    displayName = nsCString(XDisplayString(display));
+  }
+#endif
+}
+
+#ifdef MOZ_X11
+/* XApp progress support currently works by setting a property
+ * on a window with this Atom name.  A supporting window manager
+ * will notice this and pass it along to whatever handling has
+ * been implemented on that end (e.g. passing it on to a taskbar
+ * widget.)  There is no issue if WM support is lacking, this is
+ * simply ignored in that case.
+ *
+ * See https://github.com/linuxmint/xapps/blob/master/libxapp/xapp-gtk-window.c
+ * for further details.
+ */
+
+#  define PROGRESS_HINT "_NET_WM_XAPP_PROGRESS"
+
+static void set_window_hint_cardinal(Window xid, const gchar* atom_name,
+                                     gulong cardinal) {
+  GdkDisplay* display;
+
+  display = gdk_display_get_default();
+
+  if (cardinal > 0) {
+    XChangeProperty(GDK_DISPLAY_XDISPLAY(display), xid,
+                    gdk_x11_get_xatom_by_name_for_display(display, atom_name),
+                    XA_CARDINAL, 32, PropModeReplace, (guchar*)&cardinal, 1);
+  } else {
+    XDeleteProperty(GDK_DISPLAY_XDISPLAY(display), xid,
+                    gdk_x11_get_xatom_by_name_for_display(display, atom_name));
+  }
+}
+#endif  // MOZ_X11
+
+void nsWindow::SetProgress(unsigned long progressPercent) {
+#ifdef MOZ_X11
+
+  if (!GdkIsX11Display()) {
+    return;
+  }
+
+  if (!mShell) {
+    return;
+  }
+
+  progressPercent = MIN(progressPercent, 100);
+
+  set_window_hint_cardinal(GDK_WINDOW_XID(gtk_widget_get_window(mShell)),
+                           PROGRESS_HINT, progressPercent);
+#endif  // MOZ_X11
+}
+
+#ifdef MOZ_X11
+void nsWindow::SetCompositorHint(WindowComposeRequest aState) {
+  if (!GdkIsX11Display()) {
+    return;
+  }
+
+  gulong value = aState;
+  GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
+  gdk_property_change(gtk_widget_get_window(mShell),
+                      gdk_atom_intern("_NET_WM_BYPASS_COMPOSITOR", FALSE),
+                      cardinal_atom,
+                      32,  // format
+                      GDK_PROP_MODE_REPLACE, (guchar*)&value, 1);
+}
+#endif
+
+nsresult nsWindow::SetSystemFont(const nsCString& aFontName) {
+  GtkSettings* settings = gtk_settings_get_default();
+  g_object_set(settings, "gtk-font-name", aFontName.get(), nullptr);
+  return NS_OK;
+}
+
+nsresult nsWindow::GetSystemFont(nsCString& aFontName) {
+  GtkSettings* settings = gtk_settings_get_default();
+  gchar* fontName = nullptr;
+  g_object_get(settings, "gtk-font-name", &fontName, nullptr);
+  if (fontName) {
+    aFontName.Assign(fontName);
+    g_free(fontName);
+  }
+  return NS_OK;
+}
+
+already_AddRefed<nsIWidget> nsIWidget::CreateTopLevelWindow() {
+  nsCOMPtr<nsIWidget> window = new nsWindow();
+  return window.forget();
+}
+
+already_AddRefed<nsIWidget> nsIWidget::CreateChildWindow() {
+  nsCOMPtr<nsIWidget> window = new nsWindow();
+  return window.forget();
+}
+
+#ifdef MOZ_WAYLAND
+static void relative_pointer_handle_relative_motion(
+    void* data, struct zwp_relative_pointer_v1* pointer, uint32_t time_hi,
+    uint32_t time_lo, wl_fixed_t dx_w, wl_fixed_t dy_w, wl_fixed_t dx_unaccel_w,
+    wl_fixed_t dy_unaccel_w) {
+  RefPtr<nsWindow> window(reinterpret_cast<nsWindow*>(data));
+
+  WidgetMouseEvent event(true, eMouseMove, window, WidgetMouseEvent::eReal);
+
+  event.mRefPoint = window->GetNativePointerLockCenter();
+  event.mRefPoint.x += wl_fixed_to_int(dx_w);
+  event.mRefPoint.y += wl_fixed_to_int(dy_w);
+
+  event.AssignEventTime(window->GetWidgetEventTime(time_lo));
+  window->DispatchInputEvent(&event);
+}
+
+static const struct zwp_relative_pointer_v1_listener relative_pointer_listener =
+    {
+        relative_pointer_handle_relative_motion,
+};
+
+void nsWindow::SetNativePointerLockCenter(
+    const LayoutDeviceIntPoint& aLockCenter) {
+  mNativePointerLockCenter = aLockCenter;
+}
+
+void nsWindow::LockNativePointer() {
+  if (!GdkIsWaylandDisplay()) {
+    return;
+  }
+
+  auto waylandDisplay = WaylandDisplayGet();
+
+  auto* pointerConstraints = waylandDisplay->GetPointerConstraints();
+  if (!pointerConstraints) {
+    return;
+  }
+
+  auto* relativePointerMgr = waylandDisplay->GetRelativePointerManager();
+  if (!relativePointerMgr) {
+    return;
+  }
+
+  GdkDisplay* display = gdk_display_get_default();
+
+  GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+  MOZ_ASSERT(manager);
+
+  GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+  if (!device) {
+    NS_WARNING("Could not find Wayland pointer to lock");
+    return;
+  }
+  wl_pointer* pointer = gdk_wayland_device_get_wl_pointer(device);
+  MOZ_ASSERT(pointer);
+
+  wl_surface* surface =
+      gdk_wayland_window_get_wl_surface(gtk_widget_get_window(GetGtkWidget()));
+  if (!surface) {
+    /* Can be null when the window is hidden.
+     * Though it's unlikely that a lock request comes in that case, be
+     * defensive. */
+    return;
+  }
+
+  if (mLockedPointer || mRelativePointer) {
+    UnlockNativePointer();
+  }
+
+  mLockedPointer = zwp_pointer_constraints_v1_lock_pointer(
+      pointerConstraints, surface, pointer, nullptr,
+      ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT);
+  if (!mLockedPointer) {
+    NS_WARNING("Could not lock Wayland pointer");
+    return;
+  }
+
+  mRelativePointer = zwp_relative_pointer_manager_v1_get_relative_pointer(
+      relativePointerMgr, pointer);
+  if (!mRelativePointer) {
+    NS_WARNING("Could not create relative Wayland pointer");
+    zwp_locked_pointer_v1_destroy(mLockedPointer);
+    mLockedPointer = nullptr;
+    return;
+  }
+
+  zwp_relative_pointer_v1_add_listener(mRelativePointer,
+                                       &relative_pointer_listener, this);
+}
+
+void nsWindow::UnlockNativePointer() {
+  if (!GdkIsWaylandDisplay()) {
+    return;
+  }
+  if (mRelativePointer) {
+    zwp_relative_pointer_v1_destroy(mRelativePointer);
+    mRelativePointer = nullptr;
+  }
+  if (mLockedPointer) {
+    zwp_locked_pointer_v1_destroy(mLockedPointer);
+    mLockedPointer = nullptr;
+  }
+}
+#endif
+
+bool nsWindow::GetTopLevelWindowActiveState(nsIFrame* aFrame) {
+  // Used by window frame and button box rendering. We can end up in here in
+  // the content process when rendering one of these moz styles freely in a
+  // page. Fail in this case, there is no applicable window focus state.
+  if (!XRE_IsParentProcess()) {
+    return false;
+  }
+  // All headless windows are considered active so they are painted.
+  if (gfxPlatform::IsHeadless()) {
+    return true;
+  }
+  // Get the widget. nsIFrame's GetNearestWidget walks up the view chain
+  // until it finds a real window.
+  nsWindow* window = static_cast<nsWindow*>(aFrame->GetNearestWidget());
+  if (!window) {
+    return false;
+  }
+  return !window->mTitlebarBackdropState;
+}
+
+static nsIFrame* FindTitlebarFrame(nsIFrame* aFrame) {
+  for (nsIFrame* childFrame : aFrame->PrincipalChildList()) {
+    StyleAppearance appearance =
+        childFrame->StyleDisplay()->EffectiveAppearance();
+    if (appearance == StyleAppearance::MozWindowTitlebar ||
+        appearance == StyleAppearance::MozWindowTitlebarMaximized) {
+      return childFrame;
+    }
+
+    if (nsIFrame* foundFrame = FindTitlebarFrame(childFrame)) {
+      return foundFrame;
+    }
+  }
+  return nullptr;
+}
+
+nsIFrame* nsWindow::GetFrame() const {
+  nsView* view = nsView::GetViewFor(this);
+  if (!view) {
+    return nullptr;
+  }
+  return view->GetFrame();
+}
+
+void nsWindow::UpdateMozWindowActive() {
+  // Update activation state for the :-moz-window-inactive pseudoclass.
+  // Normally, this follows focus; we override it here to follow
+  // GDK_WINDOW_STATE_FOCUSED.
+  if (mozilla::dom::Document* document = GetDocument()) {
+    if (nsPIDOMWindowOuter* window = document->GetWindow()) {
+      if (RefPtr<mozilla::dom::BrowsingContext> bc =
+              window->GetBrowsingContext()) {
+        bc->SetIsActiveBrowserWindow(!mTitlebarBackdropState);
+      }
+    }
+  }
+}
+
+void nsWindow::ForceTitlebarRedraw(void) {
+  MOZ_ASSERT(mDrawInTitlebar, "We should not redraw invisible titlebar.");
+
+  if (!mWidgetListener || !mWidgetListener->GetPresShell()) {
+    return;
+  }
+
+  nsIFrame* frame = GetFrame();
+  if (!frame) {
+    return;
+  }
+
+  frame = FindTitlebarFrame(frame);
+  if (frame) {
+    nsIContent* content = frame->GetContent();
+    if (content) {
+      nsLayoutUtils::PostRestyleEvent(content->AsElement(), RestyleHint{0},
+                                      nsChangeHint_RepaintFrame);
+    }
+  }
+}
+
+void nsWindow::LockAspectRatio(bool aShouldLock) {
+  if (!gUseAspectRatio) {
+    return;
+  }
+
+  if (aShouldLock) {
+    int decWidth = 0, decHeight = 0;
+    AddCSDDecorationSize(&decWidth, &decHeight);
+
+    float width =
+        DevicePixelsToGdkCoordRoundDown(mLastSizeRequest.width) + decWidth;
+    float height =
+        DevicePixelsToGdkCoordRoundDown(mLastSizeRequest.height) + decHeight;
+
+    mAspectRatio = width / height;
+    LOG("nsWindow::LockAspectRatio() width %f height %f aspect %f", width,
+        height, mAspectRatio);
+  } else {
+    mAspectRatio = 0.0;
+    LOG("nsWindow::LockAspectRatio() removed aspect ratio");
+  }
+
+  ApplySizeConstraints();
+}
+
+nsWindow* nsWindow::GetFocusedWindow() { return gFocusWindow; }
+
+#ifdef MOZ_WAYLAND
+void nsWindow::SetEGLNativeWindowSize(
+    const LayoutDeviceIntSize& aEGLWindowSize) {
+  if (!mContainer || !GdkIsWaylandDisplay()) {
+    return;
+  }
+  if (moz_container_wayland_egl_window_needs_size_update(
+          mContainer, aEGLWindowSize.ToUnknownSize(), GdkCeiledScaleFactor())) {
+    LOG("nsWindow::SetEGLNativeWindowSize() %d x %d", aEGLWindowSize.width,
+        aEGLWindowSize.height);
+    moz_container_wayland_egl_window_set_size(mContainer,
+                                              aEGLWindowSize.ToUnknownSize());
+    moz_container_wayland_set_scale_factor(mContainer);
+  }
+}
+#endif
+
+LayoutDeviceIntSize nsWindow::GetMozContainerSize() {
+  LayoutDeviceIntSize size(0, 0);
+  if (mContainer) {
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(GTK_WIDGET(mContainer), &allocation);
+    double scale = FractionalScaleFactor();
+    size.width = round(allocation.width * scale);
+    size.height = round(allocation.height * scale);
+  }
+  return size;
+}
+
+nsWindow* nsWindow::GetWindow(GdkWindow* window) {
+  return get_window_for_gdk_window(window);
+}
+
+void nsWindow::ClearRenderingQueue() {
+  LOG("nsWindow::ClearRenderingQueue()");
+
+  if (mWidgetListener) {
+    mWidgetListener->RequestWindowClose(this);
+  }
+  DestroyLayerManager();
+}
+
+// Apply workaround for Mutter compositor bug (mzbz#1777269).
+//
+// When we open a popup window (tooltip for instance) attached to
+// GDK_WINDOW_TYPE_HINT_UTILITY parent popup, Mutter compositor sends bogus
+// leave/enter events to the GDK_WINDOW_TYPE_HINT_UTILITY popup.
+// That leads to immediate tooltip close. As a workaround ignore these
+// bogus events.
+//
+// We need to check two affected window types:
+//
+// - toplevel window with at least two child popups where the first one is
+//   GDK_WINDOW_TYPE_HINT_UTILITY.
+// - GDK_WINDOW_TYPE_HINT_UTILITY popup with a child popup
+//
+// We need to mask two bogus leave/enter sequences:
+//  1) Leave (popup) -> Enter (toplevel)
+//  2) Leave (toplevel) -> Enter (popup)
+//
+// TODO: persistent (non-tracked) popups with tooltip/child popups?
+//
+bool nsWindow::ApplyEnterLeaveMutterWorkaround() {
+  // Leave (toplevel) case
+  if (mWindowType == eWindowType_toplevel && mWaylandPopupNext &&
+      mWaylandPopupNext->mWaylandPopupNext &&
+      gtk_window_get_type_hint(GTK_WINDOW(mWaylandPopupNext->GetGtkWidget())) ==
+          GDK_WINDOW_TYPE_HINT_UTILITY) {
+    LOG("nsWindow::ApplyEnterLeaveMutterWorkaround(): leave toplevel");
+    return true;
+  }
+  // Leave (popup) case
+  if (IsWaylandPopup() && mWaylandPopupNext &&
+      gtk_window_get_type_hint(GTK_WINDOW(mShell)) ==
+          GDK_WINDOW_TYPE_HINT_UTILITY) {
+    LOG("nsWindow::ApplyEnterLeaveMutterWorkaround(): leave popup");
+    return true;
+  }
+  return false;
+}
+
+void nsWindow::NotifyOcclusionState(mozilla::widget::OcclusionState aState) {
+  if (mWindowType != eWindowType_toplevel) {
+    return;
+  }
+
+  bool isFullyOccluded = aState == mozilla::widget::OcclusionState::OCCLUDED;
+  if (mIsFullyOccluded == isFullyOccluded) {
+    return;
+  }
+  mIsFullyOccluded = isFullyOccluded;
+
+  LOG("nsWindow::NotifyOcclusionState() mIsFullyOccluded %d", mIsFullyOccluded);
+  if (mWidgetListener) {
+    mWidgetListener->OcclusionStateChanged(mIsFullyOccluded);
+  }
+}
+
+void nsWindow::SetDragSource(GdkDragContext* aSourceDragContext) {
+  mSourceDragContext = aSourceDragContext;
+  if (IsPopup() &&
+      (widget::GdkIsWaylandDisplay() || widget::IsXWaylandProtocol())) {
+    if (auto* menuPopupFrame = GetMenuPopupFrame(GetFrame())) {
+      menuPopupFrame->SetIsDragSource(!!aSourceDragContext);
+    }
+  }
+}
diff --git a/widget/gtk/nsWindow.h b/widget/gtk/nsWindow.h
new file mode 100644
index 0000000000..e394ced73b
--- /dev/null
+++ b/widget/gtk/nsWindow.h
@@ -0,0 +1,994 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsWindow_h__
+#define __nsWindow_h__
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "CompositorWidget.h"
+#include "MozContainer.h"
+#include "VsyncSource.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/widget/WindowSurface.h"
+#include "mozilla/widget/WindowSurfaceProvider.h"
+#include "nsBaseWidget.h"
+#include "nsGkAtoms.h"
+#include "nsIDragService.h"
+#include "nsRefPtrHashtable.h"
+#include "IMContextWrapper.h"
+
+#ifdef ACCESSIBILITY
+#  include "mozilla/a11y/LocalAccessible.h"
+#endif
+
+#ifdef MOZ_X11
+#  include <gdk/gdkx.h>
+#  include "X11UndefineNone.h"
+#endif
+#ifdef MOZ_WAYLAND
+#  include <gdk/gdkwayland.h>
+#  include "base/thread.h"
+#  include "WaylandVsyncSource.h"
+#  include "nsClipboardWayland.h"
+#endif
+
+#ifdef MOZ_LOGGING
+
+#  include "mozilla/Logging.h"
+#  include "nsTArray.h"
+#  include "Units.h"
+
+extern mozilla::LazyLogModule gWidgetLog;
+extern mozilla::LazyLogModule gWidgetDragLog;
+extern mozilla::LazyLogModule gWidgetPopupLog;
+extern mozilla::LazyLogModule gWidgetVsync;
+
+#  define LOG(str, ...)                               \
+    MOZ_LOG(IsPopup() ? gWidgetPopupLog : gWidgetLog, \
+            mozilla::LogLevel::Debug,                 \
+            ("%s: " str, GetDebugTag().get(), ##__VA_ARGS__))
+#  define LOGW(...) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#  define LOGDRAG(...) \
+    MOZ_LOG(gWidgetDragLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#  define LOG_POPUP(...) \
+    MOZ_LOG(gWidgetPopupLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#  define LOG_VSYNC(...) \
+    MOZ_LOG(gWidgetVsync, mozilla::LogLevel::Debug, (__VA_ARGS__))
+#  define LOG_ENABLED()                                         \
+    (MOZ_LOG_TEST(gWidgetPopupLog, mozilla::LogLevel::Debug) || \
+     MOZ_LOG_TEST(gWidgetLog, mozilla::LogLevel::Debug))
+
+#else
+
+#  define LOG(...)
+#  define LOGW(...)
+#  define LOGDRAG(...)
+#  define LOG_POPUP(...)
+#  define LOG_ENABLED() false
+
+#endif /* MOZ_LOGGING */
+
+#if defined(MOZ_WAYLAND) && !defined(MOZ_X11)
+typedef uintptr_t Window;
+#endif
+
+class gfxPattern;
+class nsIFrame;
+#if !GTK_CHECK_VERSION(3, 18, 0)
+struct _GdkEventTouchpadPinch;
+typedef struct _GdkEventTouchpadPinch GdkEventTouchpadPinch;
+#endif
+
+#if !GTK_CHECK_VERSION(3, 22, 0)
+typedef enum {
+  GDK_ANCHOR_FLIP_X = 1 << 0,
+  GDK_ANCHOR_FLIP_Y = 1 << 1,
+  GDK_ANCHOR_SLIDE_X = 1 << 2,
+  GDK_ANCHOR_SLIDE_Y = 1 << 3,
+  GDK_ANCHOR_RESIZE_X = 1 << 4,
+  GDK_ANCHOR_RESIZE_Y = 1 << 5,
+  GDK_ANCHOR_FLIP = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y,
+  GDK_ANCHOR_SLIDE = GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y,
+  GDK_ANCHOR_RESIZE = GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y
+} GdkAnchorHints;
+#endif
+
+namespace mozilla {
+enum class NativeKeyBindingsType : uint8_t;
+
+class TimeStamp;
+#ifdef MOZ_X11
+class CurrentX11TimeGetter;
+#endif
+}  // namespace mozilla
+
+class nsWindow final : public nsBaseWidget {
+ public:
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+  typedef mozilla::WidgetEventTime WidgetEventTime;
+  typedef mozilla::WidgetKeyboardEvent WidgetKeyboardEvent;
+  typedef mozilla::widget::PlatformCompositorWidgetDelegate
+      PlatformCompositorWidgetDelegate;
+
+  nsWindow();
+
+  static void ReleaseGlobals();
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(nsWindow, nsBaseWidget)
+
+  nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent,
+                         nsEventStatus& aStatus) override;
+
+  // called when we are destroyed
+  void OnDestroy() override;
+
+  // called to check and see if a widget's dimensions are sane
+  bool AreBoundsSane(void);
+
+  // nsIWidget
+  using nsBaseWidget::Create;  // for Create signature not overridden here
+  [[nodiscard]] nsresult Create(nsIWidget* aParent,
+                                nsNativeWidget aNativeParent,
+                                const LayoutDeviceIntRect& aRect,
+                                nsWidgetInitData* aInitData) override;
+  void Destroy() override;
+  nsIWidget* GetParent() override;
+  float GetDPI() override;
+  double GetDefaultScaleInternal() override;
+  mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() override;
+  mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScaleByScreen()
+      override;
+  void SetParent(nsIWidget* aNewParent) override;
+  void SetModal(bool aModal) override;
+  bool IsVisible() const override;
+  void ConstrainPosition(bool aAllowSlop, int32_t* aX, int32_t* aY) override;
+  void SetSizeConstraints(const SizeConstraints& aConstraints) override;
+  void LockAspectRatio(bool aShouldLock) override;
+  void Move(double aX, double aY) override;
+  void Show(bool aState) override;
+  void Resize(double aWidth, double aHeight, bool aRepaint) override;
+  void Resize(double aX, double aY, double aWidth, double aHeight,
+              bool aRepaint) override;
+  bool IsEnabled() const override;
+
+  void SetZIndex(int32_t aZIndex) override;
+  nsSizeMode SizeMode() override { return mSizeMode; }
+  void SetSizeMode(nsSizeMode aMode) override;
+  void GetWorkspaceID(nsAString& workspaceID) override;
+  void MoveToWorkspace(const nsAString& workspaceID) override;
+  void Enable(bool aState) override;
+  void SetFocus(Raise, mozilla::dom::CallerType aCallerType) override;
+  LayoutDeviceIntRect GetScreenBounds() override;
+  LayoutDeviceIntRect GetClientBounds() override;
+  LayoutDeviceIntSize GetClientSize() override;
+  LayoutDeviceIntPoint GetClientOffset() override { return mClientOffset; }
+
+  // Recomputes the client offset according to our current window position.
+  // If aNotify is true, NotifyWindowMoved will be called on client offset
+  // changes.
+  //
+  // NOTE(emilio): It seems that as long any change here update either the size
+  // or the position of the window, we should be doing fine without notifying,
+  // but this is done to preserve existing behavior.
+  void RecomputeClientOffset(bool aNotify);
+
+  void SetCursor(const Cursor&) override;
+  void Invalidate(const LayoutDeviceIntRect& aRect) override;
+  void* GetNativeData(uint32_t aDataType) override;
+  nsresult SetTitle(const nsAString& aTitle) override;
+  void SetIcon(const nsAString& aIconSpec) override;
+  void SetWindowClass(const nsAString& xulWinType) override;
+  LayoutDeviceIntPoint WidgetToScreenOffset() override;
+  void CaptureRollupEvents(bool aDoCapture) override;
+  [[nodiscard]] nsresult GetAttention(int32_t aCycleCount) override;
+  bool HasPendingInputEvent() override;
+
+  bool PrepareForFullscreenTransition(nsISupports** aData) override;
+  void PerformFullscreenTransition(FullscreenTransitionStage aStage,
+                                   uint16_t aDuration, nsISupports* aData,
+                                   nsIRunnable* aCallback) override;
+  already_AddRefed<nsIScreen> GetWidgetScreen() override;
+  nsresult MakeFullScreen(bool aFullScreen) override;
+  void HideWindowChrome(bool aShouldHide) override;
+
+  /**
+   * GetLastUserInputTime returns a timestamp for the most recent user input
+   * event.  This is intended for pointer grab requests (including drags).
+   */
+  static guint32 GetLastUserInputTime();
+
+  // utility method, -1 if no change should be made, otherwise returns a
+  // value that can be passed to gdk_window_set_decorations
+  gint ConvertBorderStyles(nsBorderStyle aStyle);
+
+  mozilla::widget::IMContextWrapper* GetIMContext() const { return mIMContext; }
+
+  bool DispatchCommandEvent(nsAtom* aCommand);
+  bool DispatchContentCommandEvent(mozilla::EventMessage aMsg);
+
+  // event callbacks
+  gboolean OnExposeEvent(cairo_t* cr);
+  gboolean OnConfigureEvent(GtkWidget* aWidget, GdkEventConfigure* aEvent);
+  void OnMap();
+  void OnUnmap();
+  void OnUnrealize();
+  void OnSizeAllocate(GtkAllocation* aAllocation);
+  void OnDeleteEvent();
+  void OnEnterNotifyEvent(GdkEventCrossing* aEvent);
+  void OnLeaveNotifyEvent(GdkEventCrossing* aEvent);
+  void OnMotionNotifyEvent(GdkEventMotion* aEvent);
+  void OnButtonPressEvent(GdkEventButton* aEvent);
+  void OnButtonReleaseEvent(GdkEventButton* aEvent);
+  void OnContainerFocusInEvent(GdkEventFocus* aEvent);
+  void OnContainerFocusOutEvent(GdkEventFocus* aEvent);
+  gboolean OnKeyPressEvent(GdkEventKey* aEvent);
+  gboolean OnKeyReleaseEvent(GdkEventKey* aEvent);
+
+  void OnScrollEvent(GdkEventScroll* aEvent);
+
+  void OnWindowStateEvent(GtkWidget* aWidget, GdkEventWindowState* aEvent);
+  void OnDragDataReceivedEvent(GtkWidget* aWidget, GdkDragContext* aDragContext,
+                               gint aX, gint aY,
+                               GtkSelectionData* aSelectionData, guint aInfo,
+                               guint aTime, gpointer aData);
+  gboolean OnPropertyNotifyEvent(GtkWidget* aWidget, GdkEventProperty* aEvent);
+  gboolean OnTouchEvent(GdkEventTouch* aEvent);
+  gboolean OnTouchpadPinchEvent(GdkEventTouchpadPinch* aEvent);
+
+  gint GetInputRegionMarginInGdkCoords();
+
+  void UpdateTopLevelOpaqueRegion();
+
+  already_AddRefed<mozilla::gfx::DrawTarget> StartRemoteDrawingInRegion(
+      const LayoutDeviceIntRegion& aInvalidRegion,
+      mozilla::layers::BufferMode* aBufferMode) override;
+  void EndRemoteDrawingInRegion(
+      mozilla::gfx::DrawTarget* aDrawTarget,
+      const LayoutDeviceIntRegion& aInvalidRegion) override;
+
+  void SetProgress(unsigned long progressPercent);
+
+  RefPtr<mozilla::VsyncDispatcher> GetVsyncDispatcher() override;
+  bool SynchronouslyRepaintOnResize() override;
+
+  void OnDPIChanged(void);
+  void OnCheckResize(void);
+  void OnCompositedChanged(void);
+  void OnScaleChanged();
+  void DispatchResized();
+
+  static guint32 sLastButtonPressTime;
+
+  MozContainer* GetMozContainer() { return mContainer; }
+  LayoutDeviceIntSize GetMozContainerSize();
+  GdkWindow* GetGdkWindow() const { return mGdkWindow; };
+  GdkWindow* GetToplevelGdkWindow() const;
+  GtkWidget* GetGtkWidget() const { return mShell; }
+  nsIFrame* GetFrame() const;
+  nsWindow* GetEffectiveParent();
+  bool IsDestroyed() const { return mIsDestroyed; }
+  bool IsMapped() const { return mIsMapped; }
+  bool IsPopup() const;
+  bool IsWaylandPopup() const;
+  bool IsPIPWindow() const { return mIsPIPWindow; };
+  bool IsDragPopup() { return mIsDragPopup; };
+
+  nsAutoCString GetDebugTag() const;
+
+  void DispatchDragEvent(mozilla::EventMessage aMsg,
+                         const LayoutDeviceIntPoint& aRefPoint, guint aTime);
+  static void UpdateDragStatus(GdkDragContext* aDragContext,
+                               nsIDragService* aDragService);
+  void SetDragSource(GdkDragContext* aSourceDragContext);
+
+  WidgetEventTime GetWidgetEventTime(guint32 aEventTime);
+  mozilla::TimeStamp GetEventTimeStamp(guint32 aEventTime);
+#ifdef MOZ_X11
+  mozilla::CurrentX11TimeGetter* GetCurrentTimeGetter();
+#endif
+
+  void SetInputContext(const InputContext& aContext,
+                       const InputContextAction& aAction) override;
+  InputContext GetInputContext() override;
+  TextEventDispatcherListener* GetNativeTextEventDispatcherListener() override;
+  MOZ_CAN_RUN_SCRIPT bool GetEditCommands(
+      mozilla::NativeKeyBindingsType aType,
+      const mozilla::WidgetKeyboardEvent& aEvent,
+      nsTArray<mozilla::CommandInt>& aCommands) override;
+
+  // These methods are for toplevel windows only.
+  void ResizeTransparencyBitmap();
+  void ApplyTransparencyBitmap();
+  void ClearTransparencyBitmap();
+
+  void SetTransparencyMode(nsTransparencyMode aMode) override;
+  nsTransparencyMode GetTransparencyMode() override;
+  void SetInputRegion(const InputRegion&) override;
+  nsresult UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect,
+                                                uint8_t* aAlphas,
+                                                int32_t aStride);
+  void ReparentNativeWidget(nsIWidget* aNewParent) override;
+
+  void UpdateTitlebarTransparencyBitmap();
+
+  nsresult SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
+                                      NativeMouseMessage aNativeMessage,
+                                      mozilla::MouseButton aButton,
+                                      nsIWidget::Modifiers aModifierFlags,
+                                      nsIObserver* aObserver) override;
+
+  nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
+                                     nsIObserver* aObserver) override {
+    return SynthesizeNativeMouseEvent(
+        aPoint, NativeMouseMessage::Move, mozilla::MouseButton::eNotPressed,
+        nsIWidget::Modifiers::NO_MODIFIERS, aObserver);
+  }
+
+  nsresult SynthesizeNativeMouseScrollEvent(
+      LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, double aDeltaX,
+      double aDeltaY, double aDeltaZ, uint32_t aModifierFlags,
+      uint32_t aAdditionalFlags, nsIObserver* aObserver) override;
+
+  nsresult SynthesizeNativeTouchPoint(uint32_t aPointerId,
+                                      TouchPointerState aPointerState,
+                                      LayoutDeviceIntPoint aPoint,
+                                      double aPointerPressure,
+                                      uint32_t aPointerOrientation,
+                                      nsIObserver* aObserver) override;
+
+  nsresult SynthesizeNativeTouchPadPinch(TouchpadGesturePhase aEventPhase,
+                                         float aScale,
+                                         LayoutDeviceIntPoint aPoint,
+                                         int32_t aModifierFlags) override;
+
+  nsresult SynthesizeNativeTouchpadPan(TouchpadGesturePhase aEventPhase,
+                                       LayoutDeviceIntPoint aPoint,
+                                       double aDeltaX, double aDeltaY,
+                                       int32_t aModifierFlags,
+                                       nsIObserver* aObserver) override;
+
+  void GetCompositorWidgetInitData(
+      mozilla::widget::CompositorWidgetInitData* aInitData) override;
+
+  nsresult SetNonClientMargins(LayoutDeviceIntMargin& aMargins) override;
+  void SetDrawsInTitlebar(bool aState) override;
+  mozilla::LayoutDeviceIntCoord GetTitlebarRadius();
+  LayoutDeviceIntRect GetTitlebarRect();
+  void UpdateWindowDraggingRegion(
+      const LayoutDeviceIntRegion& aRegion) override;
+
+  // HiDPI scale conversion
+  gint GdkCeiledScaleFactor();
+  bool UseFractionalScale() const;
+  double FractionalScaleFactor();
+
+  // To GDK
+  gint DevicePixelsToGdkCoordRoundUp(int);
+  gint DevicePixelsToGdkCoordRoundDown(int);
+  GdkPoint DevicePixelsToGdkPointRoundDown(const LayoutDeviceIntPoint&);
+  GdkRectangle DevicePixelsToGdkSizeRoundUp(const LayoutDeviceIntSize&);
+  GdkRectangle DevicePixelsToGdkRectRoundOut(const LayoutDeviceIntRect&);
+
+  // From GDK
+  int GdkCoordToDevicePixels(gint);
+  LayoutDeviceIntPoint GdkPointToDevicePixels(const GdkPoint&);
+  LayoutDeviceIntPoint GdkEventCoordsToDevicePixels(gdouble aX, gdouble aY);
+  LayoutDeviceIntRect GdkRectToDevicePixels(const GdkRectangle&);
+
+  bool WidgetTypeSupportsAcceleration() override;
+
+  nsresult SetSystemFont(const nsCString& aFontName) override;
+  nsresult GetSystemFont(nsCString& aFontName) override;
+
+  typedef enum {
+    GTK_DECORATION_SYSTEM,  // CSD including shadows
+    GTK_DECORATION_CLIENT,  // CSD without shadows
+    GTK_DECORATION_NONE,    // WM does not support CSD at all
+  } GtkWindowDecoration;
+  /**
+   * Get the support of Client Side Decoration by checking the desktop
+   * environment.
+   */
+  static GtkWindowDecoration GetSystemGtkWindowDecoration();
+
+  static bool GetTopLevelWindowActiveState(nsIFrame* aFrame);
+  static bool TitlebarUseShapeMask();
+  bool IsRemoteContent() { return HasRemoteContent(); }
+  void NativeMoveResizeWaylandPopupCallback(const GdkRectangle* aFinalSize,
+                                            bool aFlippedX, bool aFlippedY);
+  static bool IsToplevelWindowTransparent();
+
+  static nsWindow* GetFocusedWindow();
+
+#ifdef MOZ_WAYLAND
+  // Use xdg-activation protocol to transfer focus from gFocusWindow to aWindow.
+  static void TransferFocusToWaylandWindow(nsWindow* aWindow);
+  void FocusWaylandWindow(const char* aTokenID);
+
+  bool GetCSDDecorationOffset(int* aDx, int* aDy);
+  void SetEGLNativeWindowSize(const LayoutDeviceIntSize& aEGLWindowSize);
+  void WaylandDragWorkaround(GdkEventButton* aEvent);
+
+  wl_display* GetWaylandDisplay();
+  void CreateCompositorVsyncDispatcher() override;
+  LayoutDeviceIntPoint GetNativePointerLockCenter() {
+    return mNativePointerLockCenter;
+  }
+  void SetNativePointerLockCenter(
+      const LayoutDeviceIntPoint& aLockCenter) override;
+  void LockNativePointer() override;
+  void UnlockNativePointer() override;
+  LayoutDeviceIntSize GetMoveToRectPopupSize() const override {
+    return mMoveToRectPopupSize;
+  };
+#endif
+
+  typedef enum {
+    // WebRender compositor is enabled
+    COMPOSITOR_ENABLED,
+    // WebRender compositor is paused as we're repainting whole window and
+    // we're waiting for content process to update page content.
+    COMPOSITOR_PAUSED_FLICKERING
+  } WindowCompositorState;
+
+  // Pause compositor to avoid rendering artifacts from content process.
+  void ResumeCompositorImpl();
+  void ResumeCompositorFlickering();
+  void ResumeCompositorFromCompositorThread();
+  void PauseCompositorFlickering();
+  bool IsWaitingForCompositorResume();
+
+  // Force hide this window, remove compositor etc. to avoid
+  // rendering queue blocking (see Bug 1782948).
+  void ClearRenderingQueue();
+
+  bool ApplyEnterLeaveMutterWorkaround();
+
+  void NotifyOcclusionState(mozilla::widget::OcclusionState aState) override;
+
+  static nsWindow* GetWindow(GdkWindow* window);
+
+ protected:
+  virtual ~nsWindow();
+
+  // event handling code
+  void DispatchActivateEvent(void);
+  void DispatchDeactivateEvent(void);
+  void MaybeDispatchResized();
+  void DispatchPanGesture(mozilla::PanGestureInput& aPanInput);
+
+  void RegisterTouchWindow() override;
+
+  nsCOMPtr<nsIWidget> mParent;
+  nsPopupType mPopupHint{};
+  int mWindowScaleFactor = 1;
+
+  void UpdateAlpha(mozilla::gfx::SourceSurface* aSourceSurface,
+                   nsIntRect aBoundsRect);
+
+  void NativeMoveResize(bool aMoved, bool aResized);
+
+  void NativeShow(bool aAction);
+  void SetHasMappedToplevel(bool aState);
+  LayoutDeviceIntSize GetSafeWindowSize(LayoutDeviceIntSize aSize);
+
+  void DispatchContextMenuEventFromMouseEvent(
+      uint16_t domButton, GdkEventButton* aEvent,
+      const mozilla::LayoutDeviceIntPoint& aRefPoint);
+
+  void TryToShowNativeWindowMenu(GdkEventButton* aEvent);
+
+  void WaylandStartVsync();
+  void WaylandStopVsync();
+  void DestroyChildWindows();
+  GtkWidget* GetToplevelWidget() const;
+  nsWindow* GetContainerWindow() const;
+  Window GetX11Window();
+  bool GetShapedState();
+  void EnsureGdkWindow();
+  void SetUrgencyHint(GtkWidget* top_window, bool state);
+  void SetDefaultIcon(void);
+  void SetWindowDecoration(nsBorderStyle aStyle);
+  void InitButtonEvent(mozilla::WidgetMouseEvent& aEvent,
+                       GdkEventButton* aGdkEvent,
+                       const mozilla::LayoutDeviceIntPoint& aRefPoint);
+  bool CheckForRollup(gdouble aMouseX, gdouble aMouseY, bool aIsWheel,
+                      bool aAlwaysRollup);
+  void CheckForRollupDuringGrab() { CheckForRollup(0, 0, false, true); }
+
+  bool GetDragInfo(mozilla::WidgetMouseEvent* aMouseEvent, GdkWindow** aWindow,
+                   gint* aButton, gint* aRootX, gint* aRootY);
+  nsIWidgetListener* GetListener();
+
+  nsWindow* GetTransientForWindowIfPopup();
+  bool IsHandlingTouchSequence(GdkEventSequence* aSequence);
+
+  void ResizeInt(const mozilla::Maybe<LayoutDeviceIntPoint>& aMove,
+                 LayoutDeviceIntSize aSize);
+  void NativeMoveResizeWaylandPopup(bool aMove, bool aResize);
+
+  // Returns true if the given point (in device pixels) is within a resizer
+  // region of the window. Only used when drawing decorations client side.
+  bool CheckResizerEdge(LayoutDeviceIntPoint aPoint, GdkWindowEdge& aOutEdge);
+
+  GtkTextDirection GetTextDirection();
+
+  void AddCSDDecorationSize(int* aWidth, int* aHeight);
+
+  void CreateAndPutGdkScrollEvent(mozilla::LayoutDeviceIntPoint aPoint,
+                                  double aDeltaX, double aDeltaY);
+
+  nsCString mGtkWindowAppName;
+  nsCString mGtkWindowRoleName;
+  void RefreshWindowClass();
+
+  GtkWidget* mShell = nullptr;
+  MozContainer* mContainer = nullptr;
+  GdkWindow* mGdkWindow = nullptr;
+  PlatformCompositorWidgetDelegate* mCompositorWidgetDelegate = nullptr;
+  mozilla::Atomic<WindowCompositorState, mozilla::Relaxed> mCompositorState{
+      COMPOSITOR_ENABLED};
+  // This is used in COMPOSITOR_PAUSED_FLICKERING mode only to resume compositor
+  // in some reasonable time when page content is not updated.
+  guint mCompositorPauseTimeoutID = 0;
+
+  // The actual size mode that's in effect.
+  nsSizeMode mSizeMode = nsSizeMode_Normal;
+  // The last size mode we've requested. This might not match mSizeMode if
+  // there's a request to change the size mode in progress.
+  nsSizeMode mLastSizeModeRequest = nsSizeMode_Normal;
+  nsSizeMode mLastSizeModeBeforeFullscreen = nsSizeMode_Normal;
+
+  float mAspectRatio = 0.0f;
+  float mAspectRatioSaved = 0.0f;
+
+  // The size requested, which might not be reflected in mBounds.  Used in
+  // WaylandPopupSetDirectPosition() to remember intended size for popup
+  // positioning, in LockAspect() to remember the intended aspect ratio, and
+  // to remember a size requested while waiting for moved-to-rect when
+  // OnSizeAllocate() might change mBounds.Size().
+  LayoutDeviceIntSize mLastSizeRequest;
+  LayoutDeviceIntPoint mClientOffset;
+  // Indicates a new size that still needs to be dispatched.
+  LayoutDeviceIntSize mNeedsDispatchSize = LayoutDeviceIntSize(-1, -1);
+
+  // This field omits duplicate scroll events caused by GNOME bug 726878.
+  guint32 mLastScrollEventTime = GDK_CURRENT_TIME;
+  mozilla::ScreenCoord mLastPinchEventSpan;
+
+  struct TouchpadPinchGestureState {
+    // Focus point of the PHASE_BEGIN event
+    ScreenPoint mBeginFocus;
+
+    // Focus point of the most recent PHASE_UPDATE event
+    ScreenPoint mCurrentFocus;
+  };
+
+  // Used for handling touchpad pinch gestures
+  ScreenPoint mCurrentTouchpadFocus;
+
+  // Used for synthesizing touchpad pinch gestures
+  TouchpadPinchGestureState mCurrentSynthesizedTouchpadPinch;
+
+  // Used for synthesizing touchpad pan gestures
+  struct TouchpadPanGestureState {
+    mozilla::Maybe<TouchpadGesturePhase> mTouchpadGesturePhase;
+    uint64_t mSavedObserver = 0;
+  };
+
+  // Used for synthesizing touchpad pan gestures
+  TouchpadPanGestureState mCurrentSynthesizedTouchpadPan;
+
+  // for touch event handling
+  nsRefPtrHashtable<nsPtrHashKey<GdkEventSequence>, mozilla::dom::Touch>
+      mTouches;
+
+  // Upper bound on pending ConfigureNotify events to be dispatched to the
+  // window. See bug 1225044.
+  unsigned int mPendingConfigures = 0;
+
+  // Window titlebar rendering mode, GTK_DECORATION_NONE if it's disabled
+  // for this window.
+  GtkWindowDecoration mGtkWindowDecoration = GTK_DECORATION_NONE;
+
+  // Draggable titlebar region maintained by UpdateWindowDraggingRegion
+  LayoutDeviceIntRegion mDraggableRegion;
+
+  // The cursor cache
+  static GdkCursor* gsGtkCursorCache[eCursorCount];
+
+  // If true, draw our own window titlebar.
+  //
+  // Needs to be atomic because GetTitlebarRect() gets called from non-main
+  // threads.
+  //
+  // FIXME(emilio): GetTitlebarRect() reads other things that TSAN doesn't
+  // catch because mDrawInTitlebar is false on automation ~always. We should
+  // probably make GetTitlebarRect() simpler / properly thread-safe.
+  mozilla::Atomic<bool, mozilla::Relaxed> mDrawInTitlebar{false};
+
+  // Has this widget been destroyed yet?
+  bool mIsDestroyed;
+  // mIsShown tracks requested visible status from browser perspective, i.e.
+  // if the window should be visible or now.
+  bool mIsShown : 1;
+  // mNeedsShow is set when browser requested to show this window but we failed
+  // to do so for some reason (wrong window size for instance).
+  // In such case we set mIsShown = true and mNeedsShow = true to indicate
+  // that the window is not actually visible but we report to browser that
+  // it is visible (mIsShown == true).
+  bool mNeedsShow : 1;
+  // This track real window visibility from OS perspective.
+  // It's set by OnMap/OnUnrealize which is based on Gtk events.
+  bool mIsMapped : 1;
+  // is this widget enabled?
+  bool mEnabled : 1;
+  // has the native window for this been created yet?
+  bool mCreated : 1;
+  // whether we handle touch event
+  bool mHandleTouchEvent : 1;
+  // true if this is a drag and drop feedback popup
+  bool mIsDragPopup : 1;
+  bool mWindowScaleFactorChanged : 1;
+  bool mCompositedScreen : 1;
+  bool mIsAccelerated : 1;
+  bool mWindowShouldStartDragging : 1;
+  bool mHasMappedToplevel : 1;
+  bool mRetryPointerGrab : 1;
+  bool mPanInProgress : 1;
+  // Use dedicated GdkWindow for mContainer
+  bool mDrawToContainer : 1;
+  // Draw titlebar with :backdrop css state (inactive/unfocused).
+  bool mTitlebarBackdropState : 1;
+  // It's PictureInPicture window.
+  bool mIsPIPWindow : 1;
+  // It's undecorated popup utility window, without resizers/titlebar,
+  // movable by mouse. Used on Wayland for popups without
+  // parent (for instance WebRTC sharing indicator, notifications).
+  bool mIsWaylandPanelWindow : 1;
+  // It's child window, i.e. window which is nested in parent window.
+  // This is obsoleted and should not be used.
+  // We use GdkWindow hierarchy for such windows.
+  bool mIsChildWindow : 1;
+  bool mAlwaysOnTop : 1;
+  bool mNoAutoHide : 1;
+  bool mIsTransparent : 1;
+  // We can expect at least one size-allocate event after early resizes.
+  bool mHasReceivedSizeAllocate : 1;
+
+  /*  Gkt creates popup in two incarnations - wl_subsurface and xdg_popup.
+   *  Kind of popup is choosen before GdkWindow is mapped so we can change
+   *  it only when GdkWindow is hidden.
+   *
+   *  Relevant Gtk code is at gdkwindow-wayland.c
+   *  in should_map_as_popup() and should_map_as_subsurface()
+   *
+   *  wl_subsurface:
+   *    - can't be positioned by move-to-rect
+   *    - can stand outside popup widget hierarchy (has toplevel as parent)
+   *    - don't have child popup widgets
+   *
+   *  xdg_popup:
+   *    - can be positioned by move-to-rect
+   *    - aligned in popup widget hierarchy, first one is attached to toplevel
+   *    - has child (popup) widgets
+   *
+   *  Thus we need to map Firefox popup type to desired Gtk one:
+   *
+   *  wl_subsurface:
+   *    - pernament panels
+   *
+   *  xdg_popup:
+   *    - menus
+   *    - autohide popups (hamburger menu)
+   *    - extension popups
+   *    - tooltips
+   *
+   *  We set mPopupTrackInHierarchy = false for pernament panels which
+   *  are always mapped to toplevel and painted as wl_surfaces.
+   */
+  bool mPopupTrackInHierarchy : 1;
+  bool mPopupTrackInHierarchyConfigured : 1;
+
+  /* On X11 Gtk tends to ignore window position requests when gtk_window
+   * is hidden. Save the position requests at mPopupPosition and apply
+   * when the widget is shown.
+   */
+  bool mHiddenPopupPositioned : 1;
+
+  // The transparency bitmap is used instead of ARGB visual for toplevel
+  // window to draw titlebar.
+  bool mTransparencyBitmapForTitlebar : 1;
+
+  // True when we're on compositing window manager and this
+  // window is using visual with alpha channel.
+  bool mHasAlphaVisual : 1;
+
+  // When popup is anchored, mPopupPosition is relative to its parent popup.
+  bool mPopupAnchored : 1;
+
+  // When popup is context menu.
+  bool mPopupContextMenu : 1;
+
+  // Indicates that this popup matches layout setup so we can use parent popup
+  // coordinates reliably.
+  bool mPopupMatchesLayout : 1;
+
+  /*  Indicates that popup setup was changed and
+   *  we need to recalculate popup coordinates.
+   */
+  bool mPopupChanged : 1;
+
+  // Popup is hidden only as a part of hierarchy tree update.
+  bool mPopupTemporaryHidden : 1;
+
+  // Popup is going to be closed and removed.
+  bool mPopupClosed : 1;
+
+  // Popup is positioned by gdk_window_move_to_rect()
+  bool mPopupUseMoveToRect : 1;
+
+  /* mWaitingForMoveToRectCallback is set when move-to-rect is called
+   * and we're waiting for move-to-rect callback.
+   *
+   * If another position/resize request comes between move-to-rect call and
+   * move-to-rect callback we set mMovedAfterMoveToRect/mResizedAfterMoveToRect.
+   */
+  bool mWaitingForMoveToRectCallback : 1;
+  bool mMovedAfterMoveToRect : 1;
+  bool mResizedAfterMoveToRect : 1;
+
+  // Params used for popup placemend by GdkWindowMoveToRect.
+  // When popup is only resized and not positioned,
+  // we need to reuse last GdkWindowMoveToRect params to avoid
+  // popup movement.
+  struct WaylandPopupMoveToRectParams {
+    LayoutDeviceIntRect mAnchorRect = {0, 0, 0, 0};
+    GdkGravity mAnchorRectType = GDK_GRAVITY_NORTH_WEST;
+    GdkGravity mPopupAnchorType = GDK_GRAVITY_NORTH_WEST;
+    GdkAnchorHints mHints = GDK_ANCHOR_SLIDE;
+    GdkPoint mOffset = {0, 0};
+    bool mAnchorSet = false;
+  };
+
+  WaylandPopupMoveToRectParams mPopupMoveToRectParams;
+
+  // Whether we've configured default clear color already.
+  bool mConfiguredClearColor : 1;
+  // Whether we've received a non-blank paint in which case we can reset the
+  // clear color to transparent.
+  bool mGotNonBlankPaint : 1;
+
+  // Whether we need to retry capturing the mouse because we' re not mapped yet.
+  bool mNeedsToRetryCapturingMouse : 1;
+
+  // This bitmap tracks which pixels are transparent. We don't support
+  // full translucency at this time; each pixel is either fully opaque
+  // or fully transparent.
+  gchar* mTransparencyBitmap = nullptr;
+  int32_t mTransparencyBitmapWidth = 0;
+  int32_t mTransparencyBitmapHeight = 0;
+
+  // all of our DND stuff
+  void InitDragEvent(mozilla::WidgetDragEvent& aEvent);
+
+  float mLastMotionPressure = 0.0f;
+
+  InputRegion mInputRegion;
+
+  static bool DragInProgress(void);
+
+  void DispatchMissedButtonReleases(GdkEventCrossing* aGdkEvent);
+
+  // When window widget gets mapped/unmapped we need to configure
+  // underlying GdkWindow properly. Otherwise we'll end up with
+  // rendering to released window.
+  void ConfigureGdkWindow();
+  void ReleaseGdkWindow();
+  void ConfigureCompositor();
+
+  // nsBaseWidget
+  WindowRenderer* GetWindowRenderer() override;
+  void DidGetNonBlankPaint() override;
+
+  void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override;
+
+  int32_t RoundsWidgetCoordinatesTo() override;
+
+  void UpdateMozWindowActive();
+
+  void ForceTitlebarRedraw();
+  bool DoDrawTilebarCorners();
+  bool IsChromeWindowTitlebar();
+
+  void SetPopupWindowDecoration(bool aShowOnTaskbar);
+
+  void ApplySizeConstraints();
+
+  // Wayland Popup section
+  GdkPoint WaylandGetParentPosition();
+  bool WaylandPopupConfigure();
+  bool WaylandPopupIsAnchored();
+  bool WaylandPopupIsMenu();
+  bool WaylandPopupIsContextMenu();
+  bool WaylandPopupIsPermanent();
+  // First popup means it's attached directly to toplevel window
+  bool WaylandPopupIsFirst();
+  bool IsWidgetOverflowWindow();
+  void RemovePopupFromHierarchyList();
+  void ShowWaylandPopupWindow();
+  void HideWaylandPopupWindow(bool aTemporaryHidden, bool aRemoveFromPopupList);
+  void ShowWaylandToplevelWindow();
+  void HideWaylandToplevelWindow();
+  void WaylandPopupHideTooltips();
+  void WaylandPopupCloseOrphanedPopups();
+  void AppendPopupToHierarchyList(nsWindow* aToplevelWindow);
+  void WaylandPopupHierarchyHideTemporary();
+  void WaylandPopupHierarchyShowTemporaryHidden();
+  void WaylandPopupHierarchyCalculatePositions();
+  bool IsInPopupHierarchy();
+  void AddWindowToPopupHierarchy();
+  void UpdateWaylandPopupHierarchy();
+  void WaylandPopupHierarchyHideByLayout(
+      nsTArray<nsIWidget*>* aLayoutWidgetHierarchy);
+  void WaylandPopupHierarchyValidateByLayout(
+      nsTArray<nsIWidget*>* aLayoutWidgetHierarchy);
+  void CloseAllPopupsBeforeRemotePopup();
+  void WaylandPopupHideClosedPopups();
+  void WaylandPopupPrepareForMove();
+  void WaylandPopupMoveImpl();
+  void WaylandPopupMovePlain(int aX, int aY);
+  bool WaylandPopupRemoveNegativePosition(int* aX = nullptr, int* aY = nullptr);
+  bool WaylandPopupCheckAndGetAnchor(GdkRectangle* aPopupAnchor,
+                                     GdkPoint* aOffset);
+  bool WaylandPopupAnchorAdjustForParentPopup(GdkRectangle* aPopupAnchor,
+                                              GdkPoint* aOffset);
+  nsWindow* WaylandPopupGetTopmostWindow();
+  bool IsPopupInLayoutPopupChain(nsTArray<nsIWidget*>* aLayoutWidgetHierarchy,
+                                 bool aMustMatchParent);
+  void WaylandPopupMarkAsClosed();
+  void WaylandPopupRemoveClosedPopups();
+  void WaylandPopupSetDirectPosition();
+  bool WaylandPopupFitsToplevelWindow(bool aMove);
+  const WaylandPopupMoveToRectParams WaylandPopupGetPositionFromLayout();
+  void WaylandPopupPropagateChangesToLayout(bool aMove, bool aResize);
+  nsWindow* WaylandPopupFindLast(nsWindow* aPopup);
+  GtkWindow* GetCurrentTopmostWindow() const;
+  nsAutoCString GetFrameTag() const;
+  nsCString GetPopupTypeName();
+  bool IsPopupDirectionRTL();
+
+#ifdef MOZ_LOGGING
+  void LogPopupHierarchy();
+  void LogPopupAnchorHints(int aHints);
+  void LogPopupGravity(GdkGravity aGravity);
+#endif
+
+  // mPopupPosition is the original popup position/size from layout, set by
+  // nsWindow::Move() or nsWindow::Resize().
+  // Popup position is relative to main (toplevel) window.
+  GdkPoint mPopupPosition{};
+
+  // mRelativePopupPosition is popup position calculated against
+  // recent popup parent window.
+  GdkPoint mRelativePopupPosition{};
+
+  // Toplevel window (first element) of linked list of Wayland popups. It's null
+  // if we're the toplevel.
+  RefPtr<nsWindow> mWaylandToplevel;
+
+  // Next/Previous popups in Wayland popup hierarchy.
+  RefPtr<nsWindow> mWaylandPopupNext;
+  RefPtr<nsWindow> mWaylandPopupPrev;
+
+  // When popup is resized by Gtk by move-to-rect callback,
+  // we store final popup size here. Then we use mMoveToRectPopupSize size
+  // in following popup operations unless mLayoutPopupSizeCleared is set.
+  LayoutDeviceIntSize mMoveToRectPopupSize;
+
+  /**
+   * |mIMContext| takes all IME related stuff.
+   *
+   * This is owned by the top-level nsWindow or the topmost child
+   * nsWindow embedded in a non-Gecko widget.
+   *
+   * The instance is created when the top level widget is created.  And when
+   * the widget is destroyed, it's released.  All child windows refer its
+   * ancestor widget's instance.  So, one set of IM contexts is created for
+   * all windows in a hierarchy.  If the children are released after the top
+   * level window is released, the children still have a valid pointer,
+   * however, IME doesn't work at that time.
+   */
+  RefPtr<mozilla::widget::IMContextWrapper> mIMContext;
+
+#ifdef MOZ_X11
+  mozilla::UniquePtr<mozilla::CurrentX11TimeGetter> mCurrentTimeGetter;
+#endif
+  static GtkWindowDecoration sGtkWindowDecoration;
+
+  static bool sTransparentMainWindow;
+
+#ifdef ACCESSIBILITY
+  RefPtr<mozilla::a11y::LocalAccessible> mRootAccessible;
+
+  /**
+   * Request to create the accessible for this window if it is top level.
+   */
+  void CreateRootAccessible();
+
+  /**
+   * Dispatch accessible event for the top level window accessible.
+   *
+   * @param  aEventType  [in] the accessible event type to dispatch
+   */
+  void DispatchEventToRootAccessible(uint32_t aEventType);
+
+  /**
+   * Dispatch accessible window activate event for the top level window
+   * accessible.
+   */
+  void DispatchActivateEventAccessible();
+
+  /**
+   * Dispatch accessible window deactivate event for the top level window
+   * accessible.
+   */
+  void DispatchDeactivateEventAccessible();
+
+  /**
+   * Dispatch accessible window maximize event for the top level window
+   * accessible.
+   */
+  void DispatchMaximizeEventAccessible();
+
+  /**
+   * Dispatch accessible window minize event for the top level window
+   * accessible.
+   */
+  void DispatchMinimizeEventAccessible();
+
+  /**
+   * Dispatch accessible window restore event for the top level window
+   * accessible.
+   */
+  void DispatchRestoreEventAccessible();
+#endif
+
+  void SetUserTimeAndStartupTokenForActivatedWindow();
+
+#ifdef MOZ_X11
+  typedef enum {GTK_WIDGET_COMPOSIDED_DEFAULT = 0,
+                GTK_WIDGET_COMPOSIDED_DISABLED = 1,
+                GTK_WIDGET_COMPOSIDED_ENABLED = 2} WindowComposeRequest;
+  void SetCompositorHint(WindowComposeRequest aState);
+  bool ConfigureX11GLVisual();
+#endif
+#ifdef MOZ_WAYLAND
+  RefPtr<mozilla::WaylandVsyncSource> mWaylandVsyncSource;
+  RefPtr<mozilla::VsyncDispatcher> mWaylandVsyncDispatcher;
+  LayoutDeviceIntPoint mNativePointerLockCenter;
+  zwp_locked_pointer_v1* mLockedPointer = nullptr;
+  zwp_relative_pointer_v1* mRelativePointer = nullptr;
+#endif
+  // An activation token from our environment (see handling of the
+  // XDG_ACTIVATION_TOKEN/DESKTOP_STARTUP_ID) env vars.
+  nsCString mWindowActivationTokenFromEnv;
+  mozilla::widget::WindowSurfaceProvider mSurfaceProvider;
+  GdkDragContext* mSourceDragContext = nullptr;
+#if MOZ_LOGGING
+  LayoutDeviceIntRect mLastLoggedBoundSize;
+  int mLastLoggedScale = -1;
+#endif
+};
+
+#endif /* __nsWindow_h__ */
diff --git a/widget/gtk/wayland/gbm.h b/widget/gtk/wayland/gbm.h
new file mode 100644
index 0000000000..bd94fa8967
--- /dev/null
+++ b/widget/gtk/wayland/gbm.h
@@ -0,0 +1,480 @@
+/*
+ * Copyright © 2011 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Benjamin Franzke <benjaminfranzke@googlemail.com>
+ */
+
+#ifndef _GBM_H_
+#define _GBM_H_
+
+#define __GBM__ 1
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \file gbm.h
+ * \brief Generic Buffer Manager
+ */
+
+struct gbm_device;
+struct gbm_bo;
+struct gbm_surface;
+
+/**
+ * \mainpage The Generic Buffer Manager
+ *
+ * This module provides an abstraction that the caller can use to request a
+ * buffer from the underlying memory management system for the platform.
+ *
+ * This allows the creation of portable code whilst still allowing access to
+ * the underlying memory manager.
+ */
+
+/**
+ * Abstraction representing the handle to a buffer allocated by the
+ * manager
+ */
+union gbm_bo_handle {
+  void* ptr;
+  int32_t s32;
+  uint32_t u32;
+  int64_t s64;
+  uint64_t u64;
+};
+
+/** Format of the allocated buffer */
+enum gbm_bo_format {
+  /** RGB with 8 bits per channel in a 32 bit value */
+  GBM_BO_FORMAT_XRGB8888,
+  /** ARGB with 8 bits per channel in a 32 bit value */
+  GBM_BO_FORMAT_ARGB8888
+};
+
+/**
+ * The FourCC format codes are taken from the drm_fourcc.h definition, and
+ * re-namespaced. New GBM formats must not be added, unless they are
+ * identical ports from drm_fourcc.
+ */
+#define __gbm_fourcc_code(a, b, c, d)                             \
+  ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | \
+   ((uint32_t)(d) << 24))
+
+#define GBM_FORMAT_BIG_ENDIAN \
+  (1 << 31) /* format is big endian instead of little endian */
+
+/* color index */
+#define GBM_FORMAT_C8 __gbm_fourcc_code('C', '8', ' ', ' ') /* [7:0] C */
+
+/* 8 bpp Red */
+#define GBM_FORMAT_R8 __gbm_fourcc_code('R', '8', ' ', ' ') /* [7:0] R */
+
+/* 16 bpp RG */
+#define GBM_FORMAT_GR88 \
+  __gbm_fourcc_code('G', 'R', '8', '8') /* [15:0] G:R 8:8 little endian */
+
+/* 8 bpp RGB */
+#define GBM_FORMAT_RGB332 \
+  __gbm_fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
+#define GBM_FORMAT_BGR233 \
+  __gbm_fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
+
+/* 16 bpp RGB */
+#define GBM_FORMAT_XRGB4444        \
+  __gbm_fourcc_code('X', 'R', '1', \
+                    '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */
+#define GBM_FORMAT_XBGR4444        \
+  __gbm_fourcc_code('X', 'B', '1', \
+                    '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */
+#define GBM_FORMAT_RGBX4444        \
+  __gbm_fourcc_code('R', 'X', '1', \
+                    '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */
+#define GBM_FORMAT_BGRX4444        \
+  __gbm_fourcc_code('B', 'X', '1', \
+                    '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */
+
+#define GBM_FORMAT_ARGB4444        \
+  __gbm_fourcc_code('A', 'R', '1', \
+                    '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */
+#define GBM_FORMAT_ABGR4444        \
+  __gbm_fourcc_code('A', 'B', '1', \
+                    '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */
+#define GBM_FORMAT_RGBA4444        \
+  __gbm_fourcc_code('R', 'A', '1', \
+                    '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */
+#define GBM_FORMAT_BGRA4444        \
+  __gbm_fourcc_code('B', 'A', '1', \
+                    '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */
+
+#define GBM_FORMAT_XRGB1555        \
+  __gbm_fourcc_code('X', 'R', '1', \
+                    '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */
+#define GBM_FORMAT_XBGR1555        \
+  __gbm_fourcc_code('X', 'B', '1', \
+                    '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */
+#define GBM_FORMAT_RGBX5551        \
+  __gbm_fourcc_code('R', 'X', '1', \
+                    '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */
+#define GBM_FORMAT_BGRX5551        \
+  __gbm_fourcc_code('B', 'X', '1', \
+                    '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */
+
+#define GBM_FORMAT_ARGB1555        \
+  __gbm_fourcc_code('A', 'R', '1', \
+                    '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */
+#define GBM_FORMAT_ABGR1555        \
+  __gbm_fourcc_code('A', 'B', '1', \
+                    '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */
+#define GBM_FORMAT_RGBA5551        \
+  __gbm_fourcc_code('R', 'A', '1', \
+                    '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */
+#define GBM_FORMAT_BGRA5551        \
+  __gbm_fourcc_code('B', 'A', '1', \
+                    '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */
+
+#define GBM_FORMAT_RGB565 \
+  __gbm_fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */
+#define GBM_FORMAT_BGR565 \
+  __gbm_fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */
+
+/* 24 bpp RGB */
+#define GBM_FORMAT_RGB888 \
+  __gbm_fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */
+#define GBM_FORMAT_BGR888 \
+  __gbm_fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */
+
+/* 32 bpp RGB */
+#define GBM_FORMAT_XRGB8888        \
+  __gbm_fourcc_code('X', 'R', '2', \
+                    '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */
+#define GBM_FORMAT_XBGR8888        \
+  __gbm_fourcc_code('X', 'B', '2', \
+                    '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */
+#define GBM_FORMAT_RGBX8888        \
+  __gbm_fourcc_code('R', 'X', '2', \
+                    '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */
+#define GBM_FORMAT_BGRX8888        \
+  __gbm_fourcc_code('B', 'X', '2', \
+                    '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */
+
+#define GBM_FORMAT_ARGB8888        \
+  __gbm_fourcc_code('A', 'R', '2', \
+                    '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */
+#define GBM_FORMAT_ABGR8888        \
+  __gbm_fourcc_code('A', 'B', '2', \
+                    '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */
+#define GBM_FORMAT_RGBA8888        \
+  __gbm_fourcc_code('R', 'A', '2', \
+                    '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */
+#define GBM_FORMAT_BGRA8888        \
+  __gbm_fourcc_code('B', 'A', '2', \
+                    '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */
+
+#define GBM_FORMAT_XRGB2101010     \
+  __gbm_fourcc_code('X', 'R', '3', \
+                    '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */
+#define GBM_FORMAT_XBGR2101010     \
+  __gbm_fourcc_code('X', 'B', '3', \
+                    '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */
+#define GBM_FORMAT_RGBX1010102     \
+  __gbm_fourcc_code('R', 'X', '3', \
+                    '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */
+#define GBM_FORMAT_BGRX1010102     \
+  __gbm_fourcc_code('B', 'X', '3', \
+                    '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */
+
+#define GBM_FORMAT_ARGB2101010     \
+  __gbm_fourcc_code('A', 'R', '3', \
+                    '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */
+#define GBM_FORMAT_ABGR2101010     \
+  __gbm_fourcc_code('A', 'B', '3', \
+                    '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */
+#define GBM_FORMAT_RGBA1010102     \
+  __gbm_fourcc_code('R', 'A', '3', \
+                    '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */
+#define GBM_FORMAT_BGRA1010102     \
+  __gbm_fourcc_code('B', 'A', '3', \
+                    '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */
+
+/* packed YCbCr */
+#define GBM_FORMAT_YUYV            \
+  __gbm_fourcc_code('Y', 'U', 'Y', \
+                    'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */
+#define GBM_FORMAT_YVYU            \
+  __gbm_fourcc_code('Y', 'V', 'Y', \
+                    'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */
+#define GBM_FORMAT_UYVY            \
+  __gbm_fourcc_code('U', 'Y', 'V', \
+                    'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */
+#define GBM_FORMAT_VYUY            \
+  __gbm_fourcc_code('V', 'Y', 'U', \
+                    'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */
+
+#define GBM_FORMAT_AYUV            \
+  __gbm_fourcc_code('A', 'Y', 'U', \
+                    'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */
+
+/*
+ * 2 plane YCbCr
+ * index 0 = Y plane, [7:0] Y
+ * index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
+ * or
+ * index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
+ */
+#define GBM_FORMAT_NV12 \
+  __gbm_fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */
+#define GBM_FORMAT_NV21 \
+  __gbm_fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */
+#define GBM_FORMAT_NV16 \
+  __gbm_fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */
+#define GBM_FORMAT_NV61 \
+  __gbm_fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */
+
+/*
+ * 3 plane YCbCr
+ * index 0: Y plane, [7:0] Y
+ * index 1: Cb plane, [7:0] Cb
+ * index 2: Cr plane, [7:0] Cr
+ * or
+ * index 1: Cr plane, [7:0] Cr
+ * index 2: Cb plane, [7:0] Cb
+ */
+#define GBM_FORMAT_YUV410          \
+  __gbm_fourcc_code('Y', 'U', 'V', \
+                    '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */
+#define GBM_FORMAT_YVU410          \
+  __gbm_fourcc_code('Y', 'V', 'U', \
+                    '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */
+#define GBM_FORMAT_YUV411          \
+  __gbm_fourcc_code('Y', 'U', '1', \
+                    '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */
+#define GBM_FORMAT_YVU411          \
+  __gbm_fourcc_code('Y', 'V', '1', \
+                    '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */
+#define GBM_FORMAT_YUV420          \
+  __gbm_fourcc_code('Y', 'U', '1', \
+                    '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */
+#define GBM_FORMAT_YVU420          \
+  __gbm_fourcc_code('Y', 'V', '1', \
+                    '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */
+#define GBM_FORMAT_YUV422          \
+  __gbm_fourcc_code('Y', 'U', '1', \
+                    '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */
+#define GBM_FORMAT_YVU422          \
+  __gbm_fourcc_code('Y', 'V', '1', \
+                    '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */
+#define GBM_FORMAT_YUV444          \
+  __gbm_fourcc_code('Y', 'U', '2', \
+                    '4') /* non-subsampled Cb (1) and Cr (2) planes */
+#define GBM_FORMAT_YVU444          \
+  __gbm_fourcc_code('Y', 'V', '2', \
+                    '4') /* non-subsampled Cr (1) and Cb (2) planes */
+
+struct gbm_format_name_desc {
+  char name[5];
+};
+
+/**
+ * Flags to indicate the intended use for the buffer - these are passed into
+ * gbm_bo_create(). The caller must set the union of all the flags that are
+ * appropriate
+ *
+ * \sa Use gbm_device_is_format_supported() to check if the combination of
+ * format and use flags are supported
+ */
+enum gbm_bo_flags {
+  /**
+   * Buffer is going to be presented to the screen using an API such as KMS
+   */
+  GBM_BO_USE_SCANOUT = (1 << 0),
+  /**
+   * Buffer is going to be used as cursor
+   */
+  GBM_BO_USE_CURSOR = (1 << 1),
+  /**
+   * Deprecated
+   */
+  GBM_BO_USE_CURSOR_64X64 = GBM_BO_USE_CURSOR,
+  /**
+   * Buffer is to be used for rendering - for example it is going to be used
+   * as the storage for a color buffer
+   */
+  GBM_BO_USE_RENDERING = (1 << 2),
+  /**
+   * Buffer can be used for gbm_bo_write.  This is guaranteed to work
+   * with GBM_BO_USE_CURSOR, but may not work for other combinations.
+   */
+  GBM_BO_USE_WRITE = (1 << 3),
+  /**
+   * Buffer is linear, i.e. not tiled.
+   */
+  GBM_BO_USE_LINEAR = (1 << 4),
+};
+
+int gbm_device_get_fd(struct gbm_device* gbm);
+
+const char* gbm_device_get_backend_name(struct gbm_device* gbm);
+
+int gbm_device_is_format_supported(struct gbm_device* gbm, uint32_t format,
+                                   uint32_t usage);
+
+int gbm_device_get_format_modifier_plane_count(struct gbm_device* gbm,
+                                               uint32_t format,
+                                               uint64_t modifier);
+
+void gbm_device_destroy(struct gbm_device* gbm);
+
+struct gbm_device* gbm_create_device(int fd);
+
+struct gbm_bo* gbm_bo_create(struct gbm_device* gbm, uint32_t width,
+                             uint32_t height, uint32_t format, uint32_t flags);
+
+struct gbm_bo* gbm_bo_create_with_modifiers(struct gbm_device* gbm,
+                                            uint32_t width, uint32_t height,
+                                            uint32_t format,
+                                            const uint64_t* modifiers,
+                                            const unsigned int count);
+#define GBM_BO_IMPORT_WL_BUFFER 0x5501
+#define GBM_BO_IMPORT_EGL_IMAGE 0x5502
+#define GBM_BO_IMPORT_FD 0x5503
+#define GBM_BO_IMPORT_FD_MODIFIER 0x5504
+
+struct gbm_import_fd_data {
+  int fd;
+  uint32_t width;
+  uint32_t height;
+  uint32_t stride;
+  uint32_t format;
+};
+
+struct gbm_import_fd_modifier_data {
+  uint32_t width;
+  uint32_t height;
+  uint32_t format;
+  uint32_t num_fds;
+  int fds[4];
+  int strides[4];
+  int offsets[4];
+  uint64_t modifier;
+};
+
+struct gbm_bo* gbm_bo_import(struct gbm_device* gbm, uint32_t type,
+                             void* buffer, uint32_t usage);
+
+/**
+ * Flags to indicate the type of mapping for the buffer - these are
+ * passed into gbm_bo_map(). The caller must set the union of all the
+ * flags that are appropriate.
+ *
+ * These flags are independent of the GBM_BO_USE_* creation flags. However,
+ * mapping the buffer may require copying to/from a staging buffer.
+ *
+ * See also: pipe_transfer_usage
+ */
+enum gbm_bo_transfer_flags {
+  /**
+   * Buffer contents read back (or accessed directly) at transfer
+   * create time.
+   */
+  GBM_BO_TRANSFER_READ = (1 << 0),
+  /**
+   * Buffer contents will be written back at unmap time
+   * (or modified as a result of being accessed directly).
+   */
+  GBM_BO_TRANSFER_WRITE = (1 << 1),
+  /**
+   * Read/modify/write
+   */
+  GBM_BO_TRANSFER_READ_WRITE = (GBM_BO_TRANSFER_READ | GBM_BO_TRANSFER_WRITE),
+};
+
+void* gbm_bo_map(struct gbm_bo* bo, uint32_t x, uint32_t y, uint32_t width,
+                 uint32_t height, uint32_t flags, uint32_t* stride,
+                 void** map_data);
+
+void gbm_bo_unmap(struct gbm_bo* bo, void* map_data);
+
+uint32_t gbm_bo_get_width(struct gbm_bo* bo);
+
+uint32_t gbm_bo_get_height(struct gbm_bo* bo);
+
+uint32_t gbm_bo_get_stride(struct gbm_bo* bo);
+
+uint32_t gbm_bo_get_stride_for_plane(struct gbm_bo* bo, int plane);
+
+uint32_t gbm_bo_get_format(struct gbm_bo* bo);
+
+uint32_t gbm_bo_get_bpp(struct gbm_bo* bo);
+
+uint32_t gbm_bo_get_offset(struct gbm_bo* bo, int plane);
+
+struct gbm_device* gbm_bo_get_device(struct gbm_bo* bo);
+
+union gbm_bo_handle gbm_bo_get_handle(struct gbm_bo* bo);
+
+int gbm_bo_get_fd(struct gbm_bo* bo);
+
+uint64_t gbm_bo_get_modifier(struct gbm_bo* bo);
+
+int gbm_bo_get_plane_count(struct gbm_bo* bo);
+
+union gbm_bo_handle gbm_bo_get_handle_for_plane(struct gbm_bo* bo, int plane);
+
+int gbm_bo_write(struct gbm_bo* bo, const void* buf, size_t count);
+
+void gbm_bo_set_user_data(struct gbm_bo* bo, void* data,
+                          void (*destroy_user_data)(struct gbm_bo*, void*));
+
+void* gbm_bo_get_user_data(struct gbm_bo* bo);
+
+void gbm_bo_destroy(struct gbm_bo* bo);
+
+struct gbm_surface* gbm_surface_create(struct gbm_device* gbm, uint32_t width,
+                                       uint32_t height, uint32_t format,
+                                       uint32_t flags);
+
+struct gbm_surface* gbm_surface_create_with_modifiers(
+    struct gbm_device* gbm, uint32_t width, uint32_t height, uint32_t format,
+    const uint64_t* modifiers, const unsigned int count);
+
+struct gbm_bo* gbm_surface_lock_front_buffer(struct gbm_surface* surface);
+
+void gbm_surface_release_buffer(struct gbm_surface* surface, struct gbm_bo* bo);
+
+int gbm_surface_has_free_buffers(struct gbm_surface* surface);
+
+void gbm_surface_destroy(struct gbm_surface* surface);
+
+char* gbm_format_get_name(uint32_t gbm_format,
+                          struct gbm_format_name_desc* desc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/idle-inhibit-unstable-v1-client-protocol.h b/widget/gtk/wayland/idle-inhibit-unstable-v1-client-protocol.h
new file mode 100644
index 0000000000..3ae2303b3c
--- /dev/null
+++ b/widget/gtk/wayland/idle-inhibit-unstable-v1-client-protocol.h
@@ -0,0 +1,228 @@
+/* Generated by wayland-scanner 1.16.0 */
+
+#ifndef IDLE_INHIBIT_UNSTABLE_V1_CLIENT_PROTOCOL_H
+#define IDLE_INHIBIT_UNSTABLE_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_idle_inhibit_unstable_v1 The idle_inhibit_unstable_v1 protocol
+ * @section page_ifaces_idle_inhibit_unstable_v1 Interfaces
+ * - @subpage page_iface_zwp_idle_inhibit_manager_v1 - control behavior when
+ * display idles
+ * - @subpage page_iface_zwp_idle_inhibitor_v1 - context object for inhibiting
+ * idle behavior
+ * @section page_copyright_idle_inhibit_unstable_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2015 Samsung Electronics Co., Ltd
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_surface;
+struct zwp_idle_inhibit_manager_v1;
+struct zwp_idle_inhibitor_v1;
+
+/**
+ * @page page_iface_zwp_idle_inhibit_manager_v1 zwp_idle_inhibit_manager_v1
+ * @section page_iface_zwp_idle_inhibit_manager_v1_desc Description
+ *
+ * This interface permits inhibiting the idle behavior such as screen
+ * blanking, locking, and screensaving.  The client binds the idle manager
+ * globally, then creates idle-inhibitor objects for each surface.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ * @section page_iface_zwp_idle_inhibit_manager_v1_api API
+ * See @ref iface_zwp_idle_inhibit_manager_v1.
+ */
+/**
+ * @defgroup iface_zwp_idle_inhibit_manager_v1 The zwp_idle_inhibit_manager_v1
+ * interface
+ *
+ * This interface permits inhibiting the idle behavior such as screen
+ * blanking, locking, and screensaving.  The client binds the idle manager
+ * globally, then creates idle-inhibitor objects for each surface.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ */
+extern const struct wl_interface zwp_idle_inhibit_manager_v1_interface;
+/**
+ * @page page_iface_zwp_idle_inhibitor_v1 zwp_idle_inhibitor_v1
+ * @section page_iface_zwp_idle_inhibitor_v1_desc Description
+ *
+ * An idle inhibitor prevents the output that the associated surface is
+ * visible on from being set to a state where it is not visually usable due
+ * to lack of user interaction (e.g. blanked, dimmed, locked, set to power
+ * save, etc.)  Any screensaver processes are also blocked from displaying.
+ *
+ * If the surface is destroyed, unmapped, becomes occluded, loses
+ * visibility, or otherwise becomes not visually relevant for the user, the
+ * idle inhibitor will not be honored by the compositor; if the surface
+ * subsequently regains visibility the inhibitor takes effect once again.
+ * Likewise, the inhibitor isn't honored if the system was already idled at
+ * the time the inhibitor was established, although if the system later
+ * de-idles and re-idles the inhibitor will take effect.
+ * @section page_iface_zwp_idle_inhibitor_v1_api API
+ * See @ref iface_zwp_idle_inhibitor_v1.
+ */
+/**
+ * @defgroup iface_zwp_idle_inhibitor_v1 The zwp_idle_inhibitor_v1 interface
+ *
+ * An idle inhibitor prevents the output that the associated surface is
+ * visible on from being set to a state where it is not visually usable due
+ * to lack of user interaction (e.g. blanked, dimmed, locked, set to power
+ * save, etc.)  Any screensaver processes are also blocked from displaying.
+ *
+ * If the surface is destroyed, unmapped, becomes occluded, loses
+ * visibility, or otherwise becomes not visually relevant for the user, the
+ * idle inhibitor will not be honored by the compositor; if the surface
+ * subsequently regains visibility the inhibitor takes effect once again.
+ * Likewise, the inhibitor isn't honored if the system was already idled at
+ * the time the inhibitor was established, although if the system later
+ * de-idles and re-idles the inhibitor will take effect.
+ */
+extern const struct wl_interface zwp_idle_inhibitor_v1_interface;
+
+#define ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY 0
+#define ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR 1
+
+/**
+ * @ingroup iface_zwp_idle_inhibit_manager_v1
+ */
+#define ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_idle_inhibit_manager_v1
+ */
+#define ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_idle_inhibit_manager_v1 */
+static inline void zwp_idle_inhibit_manager_v1_set_user_data(
+    struct zwp_idle_inhibit_manager_v1* zwp_idle_inhibit_manager_v1,
+    void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_idle_inhibit_manager_v1,
+                         user_data);
+}
+
+/** @ingroup iface_zwp_idle_inhibit_manager_v1 */
+static inline void* zwp_idle_inhibit_manager_v1_get_user_data(
+    struct zwp_idle_inhibit_manager_v1* zwp_idle_inhibit_manager_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_idle_inhibit_manager_v1);
+}
+
+static inline uint32_t zwp_idle_inhibit_manager_v1_get_version(
+    struct zwp_idle_inhibit_manager_v1* zwp_idle_inhibit_manager_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_idle_inhibit_manager_v1);
+}
+
+/**
+ * @ingroup iface_zwp_idle_inhibit_manager_v1
+ *
+ * Destroy the inhibit manager.
+ */
+static inline void zwp_idle_inhibit_manager_v1_destroy(
+    struct zwp_idle_inhibit_manager_v1* zwp_idle_inhibit_manager_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_idle_inhibit_manager_v1,
+                   ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_idle_inhibit_manager_v1);
+}
+
+/**
+ * @ingroup iface_zwp_idle_inhibit_manager_v1
+ *
+ * Create a new inhibitor object associated with the given surface.
+ */
+static inline struct zwp_idle_inhibitor_v1*
+zwp_idle_inhibit_manager_v1_create_inhibitor(
+    struct zwp_idle_inhibit_manager_v1* zwp_idle_inhibit_manager_v1,
+    struct wl_surface* surface) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor(
+      (struct wl_proxy*)zwp_idle_inhibit_manager_v1,
+      ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR,
+      &zwp_idle_inhibitor_v1_interface, NULL, surface);
+
+  return (struct zwp_idle_inhibitor_v1*)id;
+}
+
+#define ZWP_IDLE_INHIBITOR_V1_DESTROY 0
+
+/**
+ * @ingroup iface_zwp_idle_inhibitor_v1
+ */
+#define ZWP_IDLE_INHIBITOR_V1_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_idle_inhibitor_v1 */
+static inline void zwp_idle_inhibitor_v1_set_user_data(
+    struct zwp_idle_inhibitor_v1* zwp_idle_inhibitor_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_idle_inhibitor_v1, user_data);
+}
+
+/** @ingroup iface_zwp_idle_inhibitor_v1 */
+static inline void* zwp_idle_inhibitor_v1_get_user_data(
+    struct zwp_idle_inhibitor_v1* zwp_idle_inhibitor_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_idle_inhibitor_v1);
+}
+
+static inline uint32_t zwp_idle_inhibitor_v1_get_version(
+    struct zwp_idle_inhibitor_v1* zwp_idle_inhibitor_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_idle_inhibitor_v1);
+}
+
+/**
+ * @ingroup iface_zwp_idle_inhibitor_v1
+ *
+ * Remove the inhibitor effect from the associated wl_surface.
+ */
+static inline void zwp_idle_inhibitor_v1_destroy(
+    struct zwp_idle_inhibitor_v1* zwp_idle_inhibitor_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_idle_inhibitor_v1,
+                   ZWP_IDLE_INHIBITOR_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_idle_inhibitor_v1);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/idle-inhibit-unstable-v1-protocol.c b/widget/gtk/wayland/idle-inhibit-unstable-v1-protocol.c
new file mode 100644
index 0000000000..579095e003
--- /dev/null
+++ b/widget/gtk/wayland/idle-inhibit-unstable-v1-protocol.c
@@ -0,0 +1,60 @@
+/* Generated by wayland-scanner 1.16.0 */
+
+/*
+ * Copyright © 2015 Samsung Electronics Co., Ltd
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+#  define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
+#endif
+
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface zwp_idle_inhibitor_v1_interface;
+#pragma GCC visibility pop
+
+static const struct wl_interface* types[] = {
+    &zwp_idle_inhibitor_v1_interface,
+    &wl_surface_interface,
+};
+
+static const struct wl_message zwp_idle_inhibit_manager_v1_requests[] = {
+    {"destroy", "", types + 0},
+    {"create_inhibitor", "no", types + 0},
+};
+
+const struct wl_interface zwp_idle_inhibit_manager_v1_interface = {
+    "zwp_idle_inhibit_manager_v1",        1, 2,
+    zwp_idle_inhibit_manager_v1_requests, 0, NULL,
+};
+
+static const struct wl_message zwp_idle_inhibitor_v1_requests[] = {
+    {"destroy", "", types + 0},
+};
+
+const struct wl_interface zwp_idle_inhibitor_v1_interface = {
+    "zwp_idle_inhibitor_v1", 1, 1, zwp_idle_inhibitor_v1_requests, 0, NULL,
+};
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
index 0000000000..cff0426a9c
--- /dev/null
+++ b/widget/gtk/wayland/linux-dmabuf-unstable-v1-client-protocol.h
@@ -0,0 +1,650 @@
+/* Generated by wayland-scanner 1.17.0 */
+
+#ifndef LINUX_DMABUF_UNSTABLE_V1_CLIENT_PROTOCOL_H
+#define LINUX_DMABUF_UNSTABLE_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_linux_dmabuf_unstable_v1 The linux_dmabuf_unstable_v1 protocol
+ * @section page_ifaces_linux_dmabuf_unstable_v1 Interfaces
+ * - @subpage page_iface_zwp_linux_dmabuf_v1 - factory for creating dmabuf-based
+ * wl_buffers
+ * - @subpage page_iface_zwp_linux_buffer_params_v1 - parameters for creating a
+ * dmabuf-based wl_buffer
+ * @section page_copyright_linux_dmabuf_unstable_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2014, 2015 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_buffer;
+struct zwp_linux_buffer_params_v1;
+struct zwp_linux_dmabuf_v1;
+
+/**
+ * @page page_iface_zwp_linux_dmabuf_v1 zwp_linux_dmabuf_v1
+ * @section page_iface_zwp_linux_dmabuf_v1_desc Description
+ *
+ * Following the interfaces from:
+ * https://www.khronos.org/registry/egl/extensions/EXT/EGL_EXT_image_dma_buf_import.txt
+ * and the Linux DRM sub-system's AddFb2 ioctl.
+ *
+ * This interface offers ways to create generic dmabuf-based
+ * wl_buffers. Immediately after a client binds to this interface,
+ * the set of supported formats and format modifiers is sent with
+ * 'format' and 'modifier' events.
+ *
+ * The following are required from clients:
+ *
+ * - Clients must ensure that either all data in the dma-buf is
+ * coherent for all subsequent read access or that coherency is
+ * correctly handled by the underlying kernel-side dma-buf
+ * implementation.
+ *
+ * - Don't make any more attachments after sending the buffer to the
+ * compositor. Making more attachments later increases the risk of
+ * the compositor not being able to use (re-import) an existing
+ * dmabuf-based wl_buffer.
+ *
+ * The underlying graphics stack must ensure the following:
+ *
+ * - The dmabuf file descriptors relayed to the server will stay valid
+ * for the whole lifetime of the wl_buffer. This means the server may
+ * at any time use those fds to import the dmabuf into any kernel
+ * sub-system that might accept it.
+ *
+ * To create a wl_buffer from one or more dmabufs, a client creates a
+ * zwp_linux_dmabuf_params_v1 object with a zwp_linux_dmabuf_v1.create_params
+ * request. All planes required by the intended format are added with
+ * the 'add' request. Finally, a 'create' or 'create_immed' request is
+ * issued, which has the following outcome depending on the import success.
+ *
+ * The 'create' request,
+ * - on success, triggers a 'created' event which provides the final
+ * wl_buffer to the client.
+ * - on failure, triggers a 'failed' event to convey that the server
+ * cannot use the dmabufs received from the client.
+ *
+ * For the 'create_immed' request,
+ * - on success, the server immediately imports the added dmabufs to
+ * create a wl_buffer. No event is sent from the server in this case.
+ * - on failure, the server can choose to either:
+ * - terminate the client by raising a fatal error.
+ * - mark the wl_buffer as failed, and send a 'failed' event to the
+ * client. If the client uses a failed wl_buffer as an argument to any
+ * request, the behaviour is compositor implementation-defined.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ * @section page_iface_zwp_linux_dmabuf_v1_api API
+ * See @ref iface_zwp_linux_dmabuf_v1.
+ */
+/**
+ * @defgroup iface_zwp_linux_dmabuf_v1 The zwp_linux_dmabuf_v1 interface
+ *
+ * Following the interfaces from:
+ * https://www.khronos.org/registry/egl/extensions/EXT/EGL_EXT_image_dma_buf_import.txt
+ * and the Linux DRM sub-system's AddFb2 ioctl.
+ *
+ * This interface offers ways to create generic dmabuf-based
+ * wl_buffers. Immediately after a client binds to this interface,
+ * the set of supported formats and format modifiers is sent with
+ * 'format' and 'modifier' events.
+ *
+ * The following are required from clients:
+ *
+ * - Clients must ensure that either all data in the dma-buf is
+ * coherent for all subsequent read access or that coherency is
+ * correctly handled by the underlying kernel-side dma-buf
+ * implementation.
+ *
+ * - Don't make any more attachments after sending the buffer to the
+ * compositor. Making more attachments later increases the risk of
+ * the compositor not being able to use (re-import) an existing
+ * dmabuf-based wl_buffer.
+ *
+ * The underlying graphics stack must ensure the following:
+ *
+ * - The dmabuf file descriptors relayed to the server will stay valid
+ * for the whole lifetime of the wl_buffer. This means the server may
+ * at any time use those fds to import the dmabuf into any kernel
+ * sub-system that might accept it.
+ *
+ * To create a wl_buffer from one or more dmabufs, a client creates a
+ * zwp_linux_dmabuf_params_v1 object with a zwp_linux_dmabuf_v1.create_params
+ * request. All planes required by the intended format are added with
+ * the 'add' request. Finally, a 'create' or 'create_immed' request is
+ * issued, which has the following outcome depending on the import success.
+ *
+ * The 'create' request,
+ * - on success, triggers a 'created' event which provides the final
+ * wl_buffer to the client.
+ * - on failure, triggers a 'failed' event to convey that the server
+ * cannot use the dmabufs received from the client.
+ *
+ * For the 'create_immed' request,
+ * - on success, the server immediately imports the added dmabufs to
+ * create a wl_buffer. No event is sent from the server in this case.
+ * - on failure, the server can choose to either:
+ * - terminate the client by raising a fatal error.
+ * - mark the wl_buffer as failed, and send a 'failed' event to the
+ * client. If the client uses a failed wl_buffer as an argument to any
+ * request, the behaviour is compositor implementation-defined.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ */
+extern const struct wl_interface zwp_linux_dmabuf_v1_interface;
+/**
+ * @page page_iface_zwp_linux_buffer_params_v1 zwp_linux_buffer_params_v1
+ * @section page_iface_zwp_linux_buffer_params_v1_desc Description
+ *
+ * This temporary object is a collection of dmabufs and other
+ * parameters that together form a single logical buffer. The temporary
+ * object may eventually create one wl_buffer unless cancelled by
+ * destroying it before requesting 'create'.
+ *
+ * Single-planar formats only require one dmabuf, however
+ * multi-planar formats may require more than one dmabuf. For all
+ * formats, an 'add' request must be called once per plane (even if the
+ * underlying dmabuf fd is identical).
+ *
+ * You must use consecutive plane indices ('plane_idx' argument for 'add')
+ * from zero to the number of planes used by the drm_fourcc format code.
+ * All planes required by the format must be given exactly once, but can
+ * be given in any order. Each plane index can be set only once.
+ * @section page_iface_zwp_linux_buffer_params_v1_api API
+ * See @ref iface_zwp_linux_buffer_params_v1.
+ */
+/**
+ * @defgroup iface_zwp_linux_buffer_params_v1 The zwp_linux_buffer_params_v1
+ * interface
+ *
+ * This temporary object is a collection of dmabufs and other
+ * parameters that together form a single logical buffer. The temporary
+ * object may eventually create one wl_buffer unless cancelled by
+ * destroying it before requesting 'create'.
+ *
+ * Single-planar formats only require one dmabuf, however
+ * multi-planar formats may require more than one dmabuf. For all
+ * formats, an 'add' request must be called once per plane (even if the
+ * underlying dmabuf fd is identical).
+ *
+ * You must use consecutive plane indices ('plane_idx' argument for 'add')
+ * from zero to the number of planes used by the drm_fourcc format code.
+ * All planes required by the format must be given exactly once, but can
+ * be given in any order. Each plane index can be set only once.
+ */
+extern const struct wl_interface zwp_linux_buffer_params_v1_interface;
+
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ * @struct zwp_linux_dmabuf_v1_listener
+ */
+struct zwp_linux_dmabuf_v1_listener {
+  /**
+   * supported buffer format
+   *
+   * This event advertises one buffer format that the server
+   * supports. All the supported formats are advertised once when the
+   * client binds to this interface. A roundtrip after binding
+   * guarantees that the client has received all supported formats.
+   *
+   * For the definition of the format codes, see the
+   * zwp_linux_buffer_params_v1::create request.
+   *
+   * Warning: the 'format' event is likely to be deprecated and
+   * replaced with the 'modifier' event introduced in
+   * zwp_linux_dmabuf_v1 version 3, described below. Please refrain
+   * from using the information received from this event.
+   * @param format DRM_FORMAT code
+   */
+  void (*format)(void* data, struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1,
+                 uint32_t format);
+  /**
+   * supported buffer format modifier
+   *
+   * This event advertises the formats that the server supports,
+   * along with the modifiers supported for each format. All the
+   * supported modifiers for all the supported formats are advertised
+   * once when the client binds to this interface. A roundtrip after
+   * binding guarantees that the client has received all supported
+   * format-modifier pairs.
+   *
+   * For the definition of the format and modifier codes, see the
+   * zwp_linux_buffer_params_v1::create request.
+   * @param format DRM_FORMAT code
+   * @param modifier_hi high 32 bits of layout modifier
+   * @param modifier_lo low 32 bits of layout modifier
+   * @since 3
+   */
+  void (*modifier)(void* data, struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1,
+                   uint32_t format, uint32_t modifier_hi, uint32_t modifier_lo);
+};
+
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ */
+static inline int zwp_linux_dmabuf_v1_add_listener(
+    struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1,
+    const struct zwp_linux_dmabuf_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)zwp_linux_dmabuf_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define ZWP_LINUX_DMABUF_V1_DESTROY 0
+#define ZWP_LINUX_DMABUF_V1_CREATE_PARAMS 1
+
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ */
+#define ZWP_LINUX_DMABUF_V1_FORMAT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ */
+#define ZWP_LINUX_DMABUF_V1_MODIFIER_SINCE_VERSION 3
+
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ */
+#define ZWP_LINUX_DMABUF_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ */
+#define ZWP_LINUX_DMABUF_V1_CREATE_PARAMS_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_linux_dmabuf_v1 */
+static inline void zwp_linux_dmabuf_v1_set_user_data(
+    struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_linux_dmabuf_v1, user_data);
+}
+
+/** @ingroup iface_zwp_linux_dmabuf_v1 */
+static inline void* zwp_linux_dmabuf_v1_get_user_data(
+    struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_linux_dmabuf_v1);
+}
+
+static inline uint32_t zwp_linux_dmabuf_v1_get_version(
+    struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_linux_dmabuf_v1);
+}
+
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ *
+ * Objects created through this interface, especially wl_buffers, will
+ * remain valid.
+ */
+static inline void zwp_linux_dmabuf_v1_destroy(
+    struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_linux_dmabuf_v1,
+                   ZWP_LINUX_DMABUF_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_linux_dmabuf_v1);
+}
+
+/**
+ * @ingroup iface_zwp_linux_dmabuf_v1
+ *
+ * This temporary object is used to collect multiple dmabuf handles into
+ * a single batch to create a wl_buffer. It can only be used once and
+ * should be destroyed after a 'created' or 'failed' event has been
+ * received.
+ */
+static inline struct zwp_linux_buffer_params_v1*
+zwp_linux_dmabuf_v1_create_params(
+    struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1) {
+  struct wl_proxy* params_id;
+
+  params_id = wl_proxy_marshal_constructor(
+      (struct wl_proxy*)zwp_linux_dmabuf_v1, ZWP_LINUX_DMABUF_V1_CREATE_PARAMS,
+      &zwp_linux_buffer_params_v1_interface, NULL);
+
+  return (struct zwp_linux_buffer_params_v1*)params_id;
+}
+
+#ifndef ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ENUM
+#  define ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ENUM
+enum zwp_linux_buffer_params_v1_error {
+  /**
+   * the dmabuf_batch object has already been used to create a wl_buffer
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ALREADY_USED = 0,
+  /**
+   * plane index out of bounds
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX = 1,
+  /**
+   * the plane index was already set
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_SET = 2,
+  /**
+   * missing or too many planes to create a buffer
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE = 3,
+  /**
+   * format not supported
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_FORMAT = 4,
+  /**
+   * invalid width or height
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_DIMENSIONS = 5,
+  /**
+   * offset + stride * height goes out of dmabuf bounds
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS = 6,
+  /**
+   * invalid wl_buffer resulted from importing dmabufs via                the
+   * create_immed request on given buffer_params
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_WL_BUFFER = 7,
+};
+#endif /* ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ENUM */
+
+#ifndef ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_ENUM
+#  define ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_ENUM
+enum zwp_linux_buffer_params_v1_flags {
+  /**
+   * contents are y-inverted
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_Y_INVERT = 1,
+  /**
+   * content is interlaced
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_INTERLACED = 2,
+  /**
+   * bottom field first
+   */
+  ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_BOTTOM_FIRST = 4,
+};
+#endif /* ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_ENUM */
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ * @struct zwp_linux_buffer_params_v1_listener
+ */
+struct zwp_linux_buffer_params_v1_listener {
+  /**
+   * buffer creation succeeded
+   *
+   * This event indicates that the attempted buffer creation was
+   * successful. It provides the new wl_buffer referencing the
+   * dmabuf(s).
+   *
+   * Upon receiving this event, the client should destroy the
+   * zlinux_dmabuf_params object.
+   * @param buffer the newly created wl_buffer
+   */
+  void (*created)(void* data,
+                  struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1,
+                  struct wl_buffer* buffer);
+  /**
+   * buffer creation failed
+   *
+   * This event indicates that the attempted buffer creation has
+   * failed. It usually means that one of the dmabuf constraints has
+   * not been fulfilled.
+   *
+   * Upon receiving this event, the client should destroy the
+   * zlinux_buffer_params object.
+   */
+  void (*failed)(void* data,
+                 struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1);
+};
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+static inline int zwp_linux_buffer_params_v1_add_listener(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1,
+    const struct zwp_linux_buffer_params_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)zwp_linux_buffer_params_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define ZWP_LINUX_BUFFER_PARAMS_V1_DESTROY 0
+#define ZWP_LINUX_BUFFER_PARAMS_V1_ADD 1
+#define ZWP_LINUX_BUFFER_PARAMS_V1_CREATE 2
+#define ZWP_LINUX_BUFFER_PARAMS_V1_CREATE_IMMED 3
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+#define ZWP_LINUX_BUFFER_PARAMS_V1_CREATED_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+#define ZWP_LINUX_BUFFER_PARAMS_V1_FAILED_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+#define ZWP_LINUX_BUFFER_PARAMS_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+#define ZWP_LINUX_BUFFER_PARAMS_V1_ADD_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+#define ZWP_LINUX_BUFFER_PARAMS_V1_CREATE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ */
+#define ZWP_LINUX_BUFFER_PARAMS_V1_CREATE_IMMED_SINCE_VERSION 2
+
+/** @ingroup iface_zwp_linux_buffer_params_v1 */
+static inline void zwp_linux_buffer_params_v1_set_user_data(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1,
+    void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_linux_buffer_params_v1,
+                         user_data);
+}
+
+/** @ingroup iface_zwp_linux_buffer_params_v1 */
+static inline void* zwp_linux_buffer_params_v1_get_user_data(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_linux_buffer_params_v1);
+}
+
+static inline uint32_t zwp_linux_buffer_params_v1_get_version(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_linux_buffer_params_v1);
+}
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ *
+ * Cleans up the temporary data sent to the server for dmabuf-based
+ * wl_buffer creation.
+ */
+static inline void zwp_linux_buffer_params_v1_destroy(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_linux_buffer_params_v1,
+                   ZWP_LINUX_BUFFER_PARAMS_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_linux_buffer_params_v1);
+}
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ *
+ * This request adds one dmabuf to the set in this
+ * zwp_linux_buffer_params_v1.
+ *
+ * The 64-bit unsigned value combined from modifier_hi and modifier_lo
+ * is the dmabuf layout modifier. DRM AddFB2 ioctl calls this the
+ * fb modifier, which is defined in drm_mode.h of Linux UAPI.
+ * This is an opaque token. Drivers use this token to express tiling,
+ * compression, etc. driver-specific modifications to the base format
+ * defined by the DRM fourcc code.
+ *
+ * This request raises the PLANE_IDX error if plane_idx is too large.
+ * The error PLANE_SET is raised if attempting to set a plane that
+ * was already set.
+ */
+static inline void zwp_linux_buffer_params_v1_add(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1, int32_t fd,
+    uint32_t plane_idx, uint32_t offset, uint32_t stride, uint32_t modifier_hi,
+    uint32_t modifier_lo) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_linux_buffer_params_v1,
+                   ZWP_LINUX_BUFFER_PARAMS_V1_ADD, fd, plane_idx, offset,
+                   stride, modifier_hi, modifier_lo);
+}
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ *
+ * This asks for creation of a wl_buffer from the added dmabuf
+ * buffers. The wl_buffer is not created immediately but returned via
+ * the 'created' event if the dmabuf sharing succeeds. The sharing
+ * may fail at runtime for reasons a client cannot predict, in
+ * which case the 'failed' event is triggered.
+ *
+ * The 'format' argument is a DRM_FORMAT code, as defined by the
+ * libdrm's drm_fourcc.h. The Linux kernel's DRM sub-system is the
+ * authoritative source on how the format codes should work.
+ *
+ * The 'flags' is a bitfield of the flags defined in enum "flags".
+ * 'y_invert' means the that the image needs to be y-flipped.
+ *
+ * Flag 'interlaced' means that the frame in the buffer is not
+ * progressive as usual, but interlaced. An interlaced buffer as
+ * supported here must always contain both top and bottom fields.
+ * The top field always begins on the first pixel row. The temporal
+ * ordering between the two fields is top field first, unless
+ * 'bottom_first' is specified. It is undefined whether 'bottom_first'
+ * is ignored if 'interlaced' is not set.
+ *
+ * This protocol does not convey any information about field rate,
+ * duration, or timing, other than the relative ordering between the
+ * two fields in one buffer. A compositor may have to estimate the
+ * intended field rate from the incoming buffer rate. It is undefined
+ * whether the time of receiving wl_surface.commit with a new buffer
+ * attached, applying the wl_surface state, wl_surface.frame callback
+ * trigger, presentation, or any other point in the compositor cycle
+ * is used to measure the frame or field times. There is no support
+ * for detecting missed or late frames/fields/buffers either, and
+ * there is no support whatsoever for cooperating with interlaced
+ * compositor output.
+ *
+ * The composited image quality resulting from the use of interlaced
+ * buffers is explicitly undefined. A compositor may use elaborate
+ * hardware features or software to deinterlace and create progressive
+ * output frames from a sequence of interlaced input buffers, or it
+ * may produce substandard image quality. However, compositors that
+ * cannot guarantee reasonable image quality in all cases are recommended
+ * to just reject all interlaced buffers.
+ *
+ * Any argument errors, including non-positive width or height,
+ * mismatch between the number of planes and the format, bad
+ * format, bad offset or stride, may be indicated by fatal protocol
+ * errors: INCOMPLETE, INVALID_FORMAT, INVALID_DIMENSIONS,
+ * OUT_OF_BOUNDS.
+ *
+ * Dmabuf import errors in the server that are not obvious client
+ * bugs are returned via the 'failed' event as non-fatal. This
+ * allows attempting dmabuf sharing and falling back in the client
+ * if it fails.
+ *
+ * This request can be sent only once in the object's lifetime, after
+ * which the only legal request is destroy. This object should be
+ * destroyed after issuing a 'create' request. Attempting to use this
+ * object after issuing 'create' raises ALREADY_USED protocol error.
+ *
+ * It is not mandatory to issue 'create'. If a client wants to
+ * cancel the buffer creation, it can just destroy this object.
+ */
+static inline void zwp_linux_buffer_params_v1_create(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1,
+    int32_t width, int32_t height, uint32_t format, uint32_t flags) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_linux_buffer_params_v1,
+                   ZWP_LINUX_BUFFER_PARAMS_V1_CREATE, width, height, format,
+                   flags);
+}
+
+/**
+ * @ingroup iface_zwp_linux_buffer_params_v1
+ *
+ * This asks for immediate creation of a wl_buffer by importing the
+ * added dmabufs.
+ *
+ * In case of import success, no event is sent from the server, and the
+ * wl_buffer is ready to be used by the client.
+ *
+ * Upon import failure, either of the following may happen, as seen fit
+ * by the implementation:
+ * - the client is terminated with one of the following fatal protocol
+ * errors:
+ * - INCOMPLETE, INVALID_FORMAT, INVALID_DIMENSIONS, OUT_OF_BOUNDS,
+ * in case of argument errors such as mismatch between the number
+ * of planes and the format, bad format, non-positive width or
+ * height, or bad offset or stride.
+ * - INVALID_WL_BUFFER, in case the cause for failure is unknown or
+ * plaform specific.
+ * - the server creates an invalid wl_buffer, marks it as failed and
+ * sends a 'failed' event to the client. The result of using this
+ * invalid wl_buffer as an argument in any request by the client is
+ * defined by the compositor implementation.
+ *
+ * This takes the same arguments as a 'create' request, and obeys the
+ * same restrictions.
+ */
+static inline struct wl_buffer* zwp_linux_buffer_params_v1_create_immed(
+    struct zwp_linux_buffer_params_v1* zwp_linux_buffer_params_v1,
+    int32_t width, int32_t height, uint32_t format, uint32_t flags) {
+  struct wl_proxy* buffer_id;
+
+  buffer_id = wl_proxy_marshal_constructor(
+      (struct wl_proxy*)zwp_linux_buffer_params_v1,
+      ZWP_LINUX_BUFFER_PARAMS_V1_CREATE_IMMED, &wl_buffer_interface, NULL,
+      width, height, format, flags);
+
+  return (struct wl_buffer*)buffer_id;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
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
index 0000000000..51c1e8e575
--- /dev/null
+++ b/widget/gtk/wayland/linux-dmabuf-unstable-v1-protocol.c
@@ -0,0 +1,81 @@
+/* Generated by wayland-scanner 1.17.0 */
+
+/*
+ * Copyright © 2014, 2015 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_buffer_interface;
+extern const struct wl_interface zwp_linux_buffer_params_v1_interface;
+#pragma GCC visibility pop
+
+static const struct wl_interface* types[] = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    &zwp_linux_buffer_params_v1_interface,
+    &wl_buffer_interface,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    &wl_buffer_interface,
+};
+
+static const struct wl_message zwp_linux_dmabuf_v1_requests[] = {
+    {"destroy", "", types + 0},
+    {"create_params", "n", types + 6},
+};
+
+static const struct wl_message zwp_linux_dmabuf_v1_events[] = {
+    {"format", "u", types + 0},
+    {"modifier", "3uuu", types + 0},
+};
+
+const struct wl_interface zwp_linux_dmabuf_v1_interface = {
+    "zwp_linux_dmabuf_v1",        3, 2,
+    zwp_linux_dmabuf_v1_requests, 2, zwp_linux_dmabuf_v1_events,
+};
+
+static const struct wl_message zwp_linux_buffer_params_v1_requests[] = {
+    {"destroy", "", types + 0},
+    {"add", "huuuuu", types + 0},
+    {"create", "iiuu", types + 0},
+    {"create_immed", "2niiuu", types + 7},
+};
+
+static const struct wl_message zwp_linux_buffer_params_v1_events[] = {
+    {"created", "n", types + 12},
+    {"failed", "", types + 0},
+};
+
+const struct wl_interface zwp_linux_buffer_params_v1_interface = {
+    "zwp_linux_buffer_params_v1",        3, 4,
+    zwp_linux_buffer_params_v1_requests, 2, zwp_linux_buffer_params_v1_events,
+};
diff --git a/widget/gtk/wayland/moz.build b/widget/gtk/wayland/moz.build
new file mode 100644
index 0000000000..695fa46d75
--- /dev/null
+++ b/widget/gtk/wayland/moz.build
@@ -0,0 +1,37 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Widget: Gtk")
+
+SOURCES += [
+    "idle-inhibit-unstable-v1-protocol.c",
+    "linux-dmabuf-unstable-v1-protocol.c",
+    "pointer-constraints-unstable-v1-protocol.c",
+    "relative-pointer-unstable-v1-protocol.c",
+    "viewporter-protocol.c",
+    "xdg-activation-v1-protocol.c",
+    "xdg-output-unstable-v1-protocol.c",
+]
+
+EXPORTS.mozilla.widget += [
+    "gbm.h",
+    "idle-inhibit-unstable-v1-client-protocol.h",
+    "linux-dmabuf-unstable-v1-client-protocol.h",
+    "pointer-constraints-unstable-v1-client-protocol.h",
+    "relative-pointer-unstable-v1-client-protocol.h",
+    "va_drmcommon.h",
+    "viewporter-client-protocol.h",
+    "xdg-activation-v1-client-protocol.h",
+    "xdg-output-unstable-v1-client-protocol.h",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
+
+CFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
diff --git a/widget/gtk/wayland/pointer-constraints-unstable-v1-client-protocol.h b/widget/gtk/wayland/pointer-constraints-unstable-v1-client-protocol.h
new file mode 100644
index 0000000000..0f38dee226
--- /dev/null
+++ b/widget/gtk/wayland/pointer-constraints-unstable-v1-client-protocol.h
@@ -0,0 +1,650 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+#ifndef POINTER_CONSTRAINTS_UNSTABLE_V1_CLIENT_PROTOCOL_H
+#define POINTER_CONSTRAINTS_UNSTABLE_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_pointer_constraints_unstable_v1 The
+ * pointer_constraints_unstable_v1 protocol protocol for constraining pointer
+ * motions
+ *
+ * @section page_desc_pointer_constraints_unstable_v1 Description
+ *
+ * This protocol specifies a set of interfaces used for adding constraints to
+ * the motion of a pointer. Possible constraints include confining pointer
+ * motions to a given region, or locking it to its current position.
+ *
+ * In order to constrain the pointer, a client must first bind the global
+ * interface "wp_pointer_constraints" which, if a compositor supports pointer
+ * constraints, is exposed by the registry. Using the bound global object, the
+ * client uses the request that corresponds to the type of constraint it wants
+ * to make. See wp_pointer_constraints for more details.
+ *
+ * Warning! The protocol described in this file is experimental and backward
+ * incompatible changes may be made. Backward compatible changes may be added
+ * together with the corresponding interface version bump. Backward
+ * incompatible changes are done by bumping the version number in the protocol
+ * and interface names and resetting the interface version. Once the protocol
+ * is to be declared stable, the 'z' prefix and the version number in the
+ * protocol and interface names are removed and the interface version number is
+ * reset.
+ *
+ * @section page_ifaces_pointer_constraints_unstable_v1 Interfaces
+ * - @subpage page_iface_zwp_pointer_constraints_v1 - constrain the movement of
+ * a pointer
+ * - @subpage page_iface_zwp_locked_pointer_v1 - receive relative pointer motion
+ * events
+ * - @subpage page_iface_zwp_confined_pointer_v1 - confined pointer object
+ * @section page_copyright_pointer_constraints_unstable_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2014      Jonas Ådahl
+ * Copyright © 2015      Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_pointer;
+struct wl_region;
+struct wl_surface;
+struct zwp_confined_pointer_v1;
+struct zwp_locked_pointer_v1;
+struct zwp_pointer_constraints_v1;
+
+/**
+ * @page page_iface_zwp_pointer_constraints_v1 zwp_pointer_constraints_v1
+ * @section page_iface_zwp_pointer_constraints_v1_desc Description
+ *
+ * The global interface exposing pointer constraining functionality. It
+ * exposes two requests: lock_pointer for locking the pointer to its
+ * position, and confine_pointer for locking the pointer to a region.
+ *
+ * The lock_pointer and confine_pointer requests create the objects
+ * wp_locked_pointer and wp_confined_pointer respectively, and the client can
+ * use these objects to interact with the lock.
+ *
+ * For any surface, only one lock or confinement may be active across all
+ * wl_pointer objects of the same seat. If a lock or confinement is requested
+ * when another lock or confinement is active or requested on the same surface
+ * and with any of the wl_pointer objects of the same seat, an
+ * 'already_constrained' error will be raised.
+ * @section page_iface_zwp_pointer_constraints_v1_api API
+ * See @ref iface_zwp_pointer_constraints_v1.
+ */
+/**
+ * @defgroup iface_zwp_pointer_constraints_v1 The zwp_pointer_constraints_v1
+ * interface
+ *
+ * The global interface exposing pointer constraining functionality. It
+ * exposes two requests: lock_pointer for locking the pointer to its
+ * position, and confine_pointer for locking the pointer to a region.
+ *
+ * The lock_pointer and confine_pointer requests create the objects
+ * wp_locked_pointer and wp_confined_pointer respectively, and the client can
+ * use these objects to interact with the lock.
+ *
+ * For any surface, only one lock or confinement may be active across all
+ * wl_pointer objects of the same seat. If a lock or confinement is requested
+ * when another lock or confinement is active or requested on the same surface
+ * and with any of the wl_pointer objects of the same seat, an
+ * 'already_constrained' error will be raised.
+ */
+extern const struct wl_interface zwp_pointer_constraints_v1_interface;
+/**
+ * @page page_iface_zwp_locked_pointer_v1 zwp_locked_pointer_v1
+ * @section page_iface_zwp_locked_pointer_v1_desc Description
+ *
+ * The wp_locked_pointer interface represents a locked pointer state.
+ *
+ * While the lock of this object is active, the wl_pointer objects of the
+ * associated seat will not emit any wl_pointer.motion events.
+ *
+ * This object will send the event 'locked' when the lock is activated.
+ * Whenever the lock is activated, it is guaranteed that the locked surface
+ * will already have received pointer focus and that the pointer will be
+ * within the region passed to the request creating this object.
+ *
+ * To unlock the pointer, send the destroy request. This will also destroy
+ * the wp_locked_pointer object.
+ *
+ * If the compositor decides to unlock the pointer the unlocked event is
+ * sent. See wp_locked_pointer.unlock for details.
+ *
+ * When unlocking, the compositor may warp the cursor position to the set
+ * cursor position hint. If it does, it will not result in any relative
+ * motion events emitted via wp_relative_pointer.
+ *
+ * If the surface the lock was requested on is destroyed and the lock is not
+ * yet activated, the wp_locked_pointer object is now defunct and must be
+ * destroyed.
+ * @section page_iface_zwp_locked_pointer_v1_api API
+ * See @ref iface_zwp_locked_pointer_v1.
+ */
+/**
+ * @defgroup iface_zwp_locked_pointer_v1 The zwp_locked_pointer_v1 interface
+ *
+ * The wp_locked_pointer interface represents a locked pointer state.
+ *
+ * While the lock of this object is active, the wl_pointer objects of the
+ * associated seat will not emit any wl_pointer.motion events.
+ *
+ * This object will send the event 'locked' when the lock is activated.
+ * Whenever the lock is activated, it is guaranteed that the locked surface
+ * will already have received pointer focus and that the pointer will be
+ * within the region passed to the request creating this object.
+ *
+ * To unlock the pointer, send the destroy request. This will also destroy
+ * the wp_locked_pointer object.
+ *
+ * If the compositor decides to unlock the pointer the unlocked event is
+ * sent. See wp_locked_pointer.unlock for details.
+ *
+ * When unlocking, the compositor may warp the cursor position to the set
+ * cursor position hint. If it does, it will not result in any relative
+ * motion events emitted via wp_relative_pointer.
+ *
+ * If the surface the lock was requested on is destroyed and the lock is not
+ * yet activated, the wp_locked_pointer object is now defunct and must be
+ * destroyed.
+ */
+extern const struct wl_interface zwp_locked_pointer_v1_interface;
+/**
+ * @page page_iface_zwp_confined_pointer_v1 zwp_confined_pointer_v1
+ * @section page_iface_zwp_confined_pointer_v1_desc Description
+ *
+ * The wp_confined_pointer interface represents a confined pointer state.
+ *
+ * This object will send the event 'confined' when the confinement is
+ * activated. Whenever the confinement is activated, it is guaranteed that
+ * the surface the pointer is confined to will already have received pointer
+ * focus and that the pointer will be within the region passed to the request
+ * creating this object. It is up to the compositor to decide whether this
+ * requires some user interaction and if the pointer will warp to within the
+ * passed region if outside.
+ *
+ * To unconfine the pointer, send the destroy request. This will also destroy
+ * the wp_confined_pointer object.
+ *
+ * If the compositor decides to unconfine the pointer the unconfined event is
+ * sent. The wp_confined_pointer object is at this point defunct and should
+ * be destroyed.
+ * @section page_iface_zwp_confined_pointer_v1_api API
+ * See @ref iface_zwp_confined_pointer_v1.
+ */
+/**
+ * @defgroup iface_zwp_confined_pointer_v1 The zwp_confined_pointer_v1 interface
+ *
+ * The wp_confined_pointer interface represents a confined pointer state.
+ *
+ * This object will send the event 'confined' when the confinement is
+ * activated. Whenever the confinement is activated, it is guaranteed that
+ * the surface the pointer is confined to will already have received pointer
+ * focus and that the pointer will be within the region passed to the request
+ * creating this object. It is up to the compositor to decide whether this
+ * requires some user interaction and if the pointer will warp to within the
+ * passed region if outside.
+ *
+ * To unconfine the pointer, send the destroy request. This will also destroy
+ * the wp_confined_pointer object.
+ *
+ * If the compositor decides to unconfine the pointer the unconfined event is
+ * sent. The wp_confined_pointer object is at this point defunct and should
+ * be destroyed.
+ */
+extern const struct wl_interface zwp_confined_pointer_v1_interface;
+
+#ifndef ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM
+#  define ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ * wp_pointer_constraints error values
+ *
+ * These errors can be emitted in response to wp_pointer_constraints
+ * requests.
+ */
+enum zwp_pointer_constraints_v1_error {
+  /**
+   * pointer constraint already requested on that surface
+   */
+  ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED = 1,
+};
+#endif /* ZWP_POINTER_CONSTRAINTS_V1_ERROR_ENUM */
+
+#ifndef ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM
+#  define ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ * the pointer constraint may reactivate
+ *
+ * A persistent pointer constraint may again reactivate once it has
+ * been deactivated. See the corresponding deactivation event
+ * (wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) for
+ * details.
+ */
+enum zwp_pointer_constraints_v1_lifetime {
+  ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT = 1,
+  ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT = 2,
+};
+#endif /* ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ENUM */
+
+#define ZWP_POINTER_CONSTRAINTS_V1_DESTROY 0
+#define ZWP_POINTER_CONSTRAINTS_V1_LOCK_POINTER 1
+#define ZWP_POINTER_CONSTRAINTS_V1_CONFINE_POINTER 2
+
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ */
+#define ZWP_POINTER_CONSTRAINTS_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ */
+#define ZWP_POINTER_CONSTRAINTS_V1_LOCK_POINTER_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ */
+#define ZWP_POINTER_CONSTRAINTS_V1_CONFINE_POINTER_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_pointer_constraints_v1 */
+static inline void zwp_pointer_constraints_v1_set_user_data(
+    struct zwp_pointer_constraints_v1* zwp_pointer_constraints_v1,
+    void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_pointer_constraints_v1,
+                         user_data);
+}
+
+/** @ingroup iface_zwp_pointer_constraints_v1 */
+static inline void* zwp_pointer_constraints_v1_get_user_data(
+    struct zwp_pointer_constraints_v1* zwp_pointer_constraints_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_pointer_constraints_v1);
+}
+
+static inline uint32_t zwp_pointer_constraints_v1_get_version(
+    struct zwp_pointer_constraints_v1* zwp_pointer_constraints_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_pointer_constraints_v1);
+}
+
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ *
+ * Used by the client to notify the server that it will no longer use this
+ * pointer constraints object.
+ */
+static inline void zwp_pointer_constraints_v1_destroy(
+    struct zwp_pointer_constraints_v1* zwp_pointer_constraints_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_pointer_constraints_v1,
+                   ZWP_POINTER_CONSTRAINTS_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_pointer_constraints_v1);
+}
+
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ *
+ * The lock_pointer request lets the client request to disable movements of
+ * the virtual pointer (i.e. the cursor), effectively locking the pointer
+ * to a position. This request may not take effect immediately; in the
+ * future, when the compositor deems implementation-specific constraints
+ * are satisfied, the pointer lock will be activated and the compositor
+ * sends a locked event.
+ *
+ * The protocol provides no guarantee that the constraints are ever
+ * satisfied, and does not require the compositor to send an error if the
+ * constraints cannot ever be satisfied. It is thus possible to request a
+ * lock that will never activate.
+ *
+ * There may not be another pointer constraint of any kind requested or
+ * active on the surface for any of the wl_pointer objects of the seat of
+ * the passed pointer when requesting a lock. If there is, an error will be
+ * raised. See general pointer lock documentation for more details.
+ *
+ * The intersection of the region passed with this request and the input
+ * region of the surface is used to determine where the pointer must be
+ * in order for the lock to activate. It is up to the compositor whether to
+ * warp the pointer or require some kind of user interaction for the lock
+ * to activate. If the region is null the surface input region is used.
+ *
+ * A surface may receive pointer focus without the lock being activated.
+ *
+ * The request creates a new object wp_locked_pointer which is used to
+ * interact with the lock as well as receive updates about its state. See
+ * the the description of wp_locked_pointer for further information.
+ *
+ * Note that while a pointer is locked, the wl_pointer objects of the
+ * corresponding seat will not emit any wl_pointer.motion events, but
+ * relative motion events will still be emitted via wp_relative_pointer
+ * objects of the same seat. wl_pointer.axis and wl_pointer.button events
+ * are unaffected.
+ */
+static inline struct zwp_locked_pointer_v1*
+zwp_pointer_constraints_v1_lock_pointer(
+    struct zwp_pointer_constraints_v1* zwp_pointer_constraints_v1,
+    struct wl_surface* surface, struct wl_pointer* pointer,
+    struct wl_region* region, uint32_t lifetime) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor(
+      (struct wl_proxy*)zwp_pointer_constraints_v1,
+      ZWP_POINTER_CONSTRAINTS_V1_LOCK_POINTER, &zwp_locked_pointer_v1_interface,
+      NULL, surface, pointer, region, lifetime);
+
+  return (struct zwp_locked_pointer_v1*)id;
+}
+
+/**
+ * @ingroup iface_zwp_pointer_constraints_v1
+ *
+ * The confine_pointer request lets the client request to confine the
+ * pointer cursor to a given region. This request may not take effect
+ * immediately; in the future, when the compositor deems implementation-
+ * specific constraints are satisfied, the pointer confinement will be
+ * activated and the compositor sends a confined event.
+ *
+ * The intersection of the region passed with this request and the input
+ * region of the surface is used to determine where the pointer must be
+ * in order for the confinement to activate. It is up to the compositor
+ * whether to warp the pointer or require some kind of user interaction for
+ * the confinement to activate. If the region is null the surface input
+ * region is used.
+ *
+ * The request will create a new object wp_confined_pointer which is used
+ * to interact with the confinement as well as receive updates about its
+ * state. See the the description of wp_confined_pointer for further
+ * information.
+ */
+static inline struct zwp_confined_pointer_v1*
+zwp_pointer_constraints_v1_confine_pointer(
+    struct zwp_pointer_constraints_v1* zwp_pointer_constraints_v1,
+    struct wl_surface* surface, struct wl_pointer* pointer,
+    struct wl_region* region, uint32_t lifetime) {
+  struct wl_proxy* id;
+
+  id =
+      wl_proxy_marshal_constructor((struct wl_proxy*)zwp_pointer_constraints_v1,
+                                   ZWP_POINTER_CONSTRAINTS_V1_CONFINE_POINTER,
+                                   &zwp_confined_pointer_v1_interface, NULL,
+                                   surface, pointer, region, lifetime);
+
+  return (struct zwp_confined_pointer_v1*)id;
+}
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ * @struct zwp_locked_pointer_v1_listener
+ */
+struct zwp_locked_pointer_v1_listener {
+  /**
+   * lock activation event
+   *
+   * Notification that the pointer lock of the seat's pointer is
+   * activated.
+   */
+  void (*locked)(void* data,
+                 struct zwp_locked_pointer_v1* zwp_locked_pointer_v1);
+  /**
+   * lock deactivation event
+   *
+   * Notification that the pointer lock of the seat's pointer is no
+   * longer active. If this is a oneshot pointer lock (see
+   * wp_pointer_constraints.lifetime) this object is now defunct and
+   * should be destroyed. If this is a persistent pointer lock (see
+   * wp_pointer_constraints.lifetime) this pointer lock may again
+   * reactivate in the future.
+   */
+  void (*unlocked)(void* data,
+                   struct zwp_locked_pointer_v1* zwp_locked_pointer_v1);
+};
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ */
+static inline int zwp_locked_pointer_v1_add_listener(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1,
+    const struct zwp_locked_pointer_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)zwp_locked_pointer_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define ZWP_LOCKED_POINTER_V1_DESTROY 0
+#define ZWP_LOCKED_POINTER_V1_SET_CURSOR_POSITION_HINT 1
+#define ZWP_LOCKED_POINTER_V1_SET_REGION 2
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ */
+#define ZWP_LOCKED_POINTER_V1_LOCKED_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ */
+#define ZWP_LOCKED_POINTER_V1_UNLOCKED_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ */
+#define ZWP_LOCKED_POINTER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ */
+#define ZWP_LOCKED_POINTER_V1_SET_CURSOR_POSITION_HINT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ */
+#define ZWP_LOCKED_POINTER_V1_SET_REGION_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_locked_pointer_v1 */
+static inline void zwp_locked_pointer_v1_set_user_data(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_locked_pointer_v1, user_data);
+}
+
+/** @ingroup iface_zwp_locked_pointer_v1 */
+static inline void* zwp_locked_pointer_v1_get_user_data(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_locked_pointer_v1);
+}
+
+static inline uint32_t zwp_locked_pointer_v1_get_version(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_locked_pointer_v1);
+}
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ *
+ * Destroy the locked pointer object. If applicable, the compositor will
+ * unlock the pointer.
+ */
+static inline void zwp_locked_pointer_v1_destroy(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_locked_pointer_v1,
+                   ZWP_LOCKED_POINTER_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_locked_pointer_v1);
+}
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ *
+ * Set the cursor position hint relative to the top left corner of the
+ * surface.
+ *
+ * If the client is drawing its own cursor, it should update the position
+ * hint to the position of its own cursor. A compositor may use this
+ * information to warp the pointer upon unlock in order to avoid pointer
+ * jumps.
+ *
+ * The cursor position hint is double buffered. The new hint will only take
+ * effect when the associated surface gets it pending state applied. See
+ * wl_surface.commit for details.
+ */
+static inline void zwp_locked_pointer_v1_set_cursor_position_hint(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1, wl_fixed_t surface_x,
+    wl_fixed_t surface_y) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_locked_pointer_v1,
+                   ZWP_LOCKED_POINTER_V1_SET_CURSOR_POSITION_HINT, surface_x,
+                   surface_y);
+}
+
+/**
+ * @ingroup iface_zwp_locked_pointer_v1
+ *
+ * Set a new region used to lock the pointer.
+ *
+ * The new lock region is double-buffered. The new lock region will
+ * only take effect when the associated surface gets its pending state
+ * applied. See wl_surface.commit for details.
+ *
+ * For details about the lock region, see wp_locked_pointer.
+ */
+static inline void zwp_locked_pointer_v1_set_region(
+    struct zwp_locked_pointer_v1* zwp_locked_pointer_v1,
+    struct wl_region* region) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_locked_pointer_v1,
+                   ZWP_LOCKED_POINTER_V1_SET_REGION, region);
+}
+
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ * @struct zwp_confined_pointer_v1_listener
+ */
+struct zwp_confined_pointer_v1_listener {
+  /**
+   * pointer confined
+   *
+   * Notification that the pointer confinement of the seat's
+   * pointer is activated.
+   */
+  void (*confined)(void* data,
+                   struct zwp_confined_pointer_v1* zwp_confined_pointer_v1);
+  /**
+   * pointer unconfined
+   *
+   * Notification that the pointer confinement of the seat's
+   * pointer is no longer active. If this is a oneshot pointer
+   * confinement (see wp_pointer_constraints.lifetime) this object is
+   * now defunct and should be destroyed. If this is a persistent
+   * pointer confinement (see wp_pointer_constraints.lifetime) this
+   * pointer confinement may again reactivate in the future.
+   */
+  void (*unconfined)(void* data,
+                     struct zwp_confined_pointer_v1* zwp_confined_pointer_v1);
+};
+
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ */
+static inline int zwp_confined_pointer_v1_add_listener(
+    struct zwp_confined_pointer_v1* zwp_confined_pointer_v1,
+    const struct zwp_confined_pointer_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)zwp_confined_pointer_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define ZWP_CONFINED_POINTER_V1_DESTROY 0
+#define ZWP_CONFINED_POINTER_V1_SET_REGION 1
+
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ */
+#define ZWP_CONFINED_POINTER_V1_CONFINED_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ */
+#define ZWP_CONFINED_POINTER_V1_UNCONFINED_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ */
+#define ZWP_CONFINED_POINTER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ */
+#define ZWP_CONFINED_POINTER_V1_SET_REGION_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_confined_pointer_v1 */
+static inline void zwp_confined_pointer_v1_set_user_data(
+    struct zwp_confined_pointer_v1* zwp_confined_pointer_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_confined_pointer_v1, user_data);
+}
+
+/** @ingroup iface_zwp_confined_pointer_v1 */
+static inline void* zwp_confined_pointer_v1_get_user_data(
+    struct zwp_confined_pointer_v1* zwp_confined_pointer_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_confined_pointer_v1);
+}
+
+static inline uint32_t zwp_confined_pointer_v1_get_version(
+    struct zwp_confined_pointer_v1* zwp_confined_pointer_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_confined_pointer_v1);
+}
+
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ *
+ * Destroy the confined pointer object. If applicable, the compositor will
+ * unconfine the pointer.
+ */
+static inline void zwp_confined_pointer_v1_destroy(
+    struct zwp_confined_pointer_v1* zwp_confined_pointer_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_confined_pointer_v1,
+                   ZWP_CONFINED_POINTER_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_confined_pointer_v1);
+}
+
+/**
+ * @ingroup iface_zwp_confined_pointer_v1
+ *
+ * Set a new region used to confine the pointer.
+ *
+ * The new confine region is double-buffered. The new confine region will
+ * only take effect when the associated surface gets its pending state
+ * applied. See wl_surface.commit for details.
+ *
+ * If the confinement is active when the new confinement region is applied
+ * and the pointer ends up outside of newly applied region, the pointer may
+ * warped to a position within the new confinement region. If warped, a
+ * wl_pointer.motion event will be emitted, but no
+ * wp_relative_pointer.relative_motion event.
+ *
+ * The compositor may also, instead of using the new region, unconfine the
+ * pointer.
+ *
+ * For details about the confine region, see wp_confined_pointer.
+ */
+static inline void zwp_confined_pointer_v1_set_region(
+    struct zwp_confined_pointer_v1* zwp_confined_pointer_v1,
+    struct wl_region* region) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_confined_pointer_v1,
+                   ZWP_CONFINED_POINTER_V1_SET_REGION, region);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/pointer-constraints-unstable-v1-protocol.c b/widget/gtk/wayland/pointer-constraints-unstable-v1-protocol.c
new file mode 100644
index 0000000000..c28ddf6918
--- /dev/null
+++ b/widget/gtk/wayland/pointer-constraints-unstable-v1-protocol.c
@@ -0,0 +1,97 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+/*
+ * Copyright © 2014      Jonas Ådahl
+ * Copyright © 2015      Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_pointer_interface;
+extern const struct wl_interface wl_region_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface zwp_confined_pointer_v1_interface;
+extern const struct wl_interface zwp_locked_pointer_v1_interface;
+#pragma GCC visibility pop
+
+static const struct wl_interface* pointer_constraints_unstable_v1_types[] = {
+    NULL,
+    NULL,
+    &zwp_locked_pointer_v1_interface,
+    &wl_surface_interface,
+    &wl_pointer_interface,
+    &wl_region_interface,
+    NULL,
+    &zwp_confined_pointer_v1_interface,
+    &wl_surface_interface,
+    &wl_pointer_interface,
+    &wl_region_interface,
+    NULL,
+    &wl_region_interface,
+    &wl_region_interface,
+};
+
+static const struct wl_message zwp_pointer_constraints_v1_requests[] = {
+    {"destroy", "", pointer_constraints_unstable_v1_types + 0},
+    {"lock_pointer", "noo?ou", pointer_constraints_unstable_v1_types + 2},
+    {"confine_pointer", "noo?ou", pointer_constraints_unstable_v1_types + 7},
+};
+
+WL_EXPORT const struct wl_interface zwp_pointer_constraints_v1_interface = {
+    "zwp_pointer_constraints_v1",        1, 3,
+    zwp_pointer_constraints_v1_requests, 0, NULL,
+};
+
+static const struct wl_message zwp_locked_pointer_v1_requests[] = {
+    {"destroy", "", pointer_constraints_unstable_v1_types + 0},
+    {"set_cursor_position_hint", "ff",
+     pointer_constraints_unstable_v1_types + 0},
+    {"set_region", "?o", pointer_constraints_unstable_v1_types + 12},
+};
+
+static const struct wl_message zwp_locked_pointer_v1_events[] = {
+    {"locked", "", pointer_constraints_unstable_v1_types + 0},
+    {"unlocked", "", pointer_constraints_unstable_v1_types + 0},
+};
+
+WL_EXPORT const struct wl_interface zwp_locked_pointer_v1_interface = {
+    "zwp_locked_pointer_v1",        1, 3,
+    zwp_locked_pointer_v1_requests, 2, zwp_locked_pointer_v1_events,
+};
+
+static const struct wl_message zwp_confined_pointer_v1_requests[] = {
+    {"destroy", "", pointer_constraints_unstable_v1_types + 0},
+    {"set_region", "?o", pointer_constraints_unstable_v1_types + 13},
+};
+
+static const struct wl_message zwp_confined_pointer_v1_events[] = {
+    {"confined", "", pointer_constraints_unstable_v1_types + 0},
+    {"unconfined", "", pointer_constraints_unstable_v1_types + 0},
+};
+
+WL_EXPORT const struct wl_interface zwp_confined_pointer_v1_interface = {
+    "zwp_confined_pointer_v1",        1, 2,
+    zwp_confined_pointer_v1_requests, 2, zwp_confined_pointer_v1_events,
+};
diff --git a/widget/gtk/wayland/relative-pointer-unstable-v1-client-protocol.h b/widget/gtk/wayland/relative-pointer-unstable-v1-client-protocol.h
new file mode 100644
index 0000000000..dbae8081f4
--- /dev/null
+++ b/widget/gtk/wayland/relative-pointer-unstable-v1-client-protocol.h
@@ -0,0 +1,293 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+#ifndef RELATIVE_POINTER_UNSTABLE_V1_CLIENT_PROTOCOL_H
+#define RELATIVE_POINTER_UNSTABLE_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_relative_pointer_unstable_v1 The relative_pointer_unstable_v1
+ * protocol protocol for relative pointer motion events
+ *
+ * @section page_desc_relative_pointer_unstable_v1 Description
+ *
+ * This protocol specifies a set of interfaces used for making clients able to
+ * receive relative pointer events not obstructed by barriers (such as the
+ * monitor edge or other pointer barriers).
+ *
+ * To start receiving relative pointer events, a client must first bind the
+ * global interface "wp_relative_pointer_manager" which, if a compositor
+ * supports relative pointer motion events, is exposed by the registry. After
+ * having created the relative pointer manager proxy object, the client uses
+ * it to create the actual relative pointer object using the
+ * "get_relative_pointer" request given a wl_pointer. The relative pointer
+ * motion events will then, when applicable, be transmitted via the proxy of
+ * the newly created relative pointer object. See the documentation of the
+ * relative pointer interface for more details.
+ *
+ * Warning! The protocol described in this file is experimental and backward
+ * incompatible changes may be made. Backward compatible changes may be added
+ * together with the corresponding interface version bump. Backward
+ * incompatible changes are done by bumping the version number in the protocol
+ * and interface names and resetting the interface version. Once the protocol
+ * is to be declared stable, the 'z' prefix and the version number in the
+ * protocol and interface names are removed and the interface version number is
+ * reset.
+ *
+ * @section page_ifaces_relative_pointer_unstable_v1 Interfaces
+ * - @subpage page_iface_zwp_relative_pointer_manager_v1 - get relative pointer
+ * objects
+ * - @subpage page_iface_zwp_relative_pointer_v1 - relative pointer object
+ * @section page_copyright_relative_pointer_unstable_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2014      Jonas Ådahl
+ * Copyright © 2015      Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_pointer;
+struct zwp_relative_pointer_manager_v1;
+struct zwp_relative_pointer_v1;
+
+/**
+ * @page page_iface_zwp_relative_pointer_manager_v1
+ * zwp_relative_pointer_manager_v1
+ * @section page_iface_zwp_relative_pointer_manager_v1_desc Description
+ *
+ * A global interface used for getting the relative pointer object for a
+ * given pointer.
+ * @section page_iface_zwp_relative_pointer_manager_v1_api API
+ * See @ref iface_zwp_relative_pointer_manager_v1.
+ */
+/**
+ * @defgroup iface_zwp_relative_pointer_manager_v1 The
+ * zwp_relative_pointer_manager_v1 interface
+ *
+ * A global interface used for getting the relative pointer object for a
+ * given pointer.
+ */
+extern const struct wl_interface zwp_relative_pointer_manager_v1_interface;
+/**
+ * @page page_iface_zwp_relative_pointer_v1 zwp_relative_pointer_v1
+ * @section page_iface_zwp_relative_pointer_v1_desc Description
+ *
+ * A wp_relative_pointer object is an extension to the wl_pointer interface
+ * used for emitting relative pointer events. It shares the same focus as
+ * wl_pointer objects of the same seat and will only emit events when it has
+ * focus.
+ * @section page_iface_zwp_relative_pointer_v1_api API
+ * See @ref iface_zwp_relative_pointer_v1.
+ */
+/**
+ * @defgroup iface_zwp_relative_pointer_v1 The zwp_relative_pointer_v1 interface
+ *
+ * A wp_relative_pointer object is an extension to the wl_pointer interface
+ * used for emitting relative pointer events. It shares the same focus as
+ * wl_pointer objects of the same seat and will only emit events when it has
+ * focus.
+ */
+extern const struct wl_interface zwp_relative_pointer_v1_interface;
+
+#define ZWP_RELATIVE_POINTER_MANAGER_V1_DESTROY 0
+#define ZWP_RELATIVE_POINTER_MANAGER_V1_GET_RELATIVE_POINTER 1
+
+/**
+ * @ingroup iface_zwp_relative_pointer_manager_v1
+ */
+#define ZWP_RELATIVE_POINTER_MANAGER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_relative_pointer_manager_v1
+ */
+#define ZWP_RELATIVE_POINTER_MANAGER_V1_GET_RELATIVE_POINTER_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_relative_pointer_manager_v1 */
+static inline void zwp_relative_pointer_manager_v1_set_user_data(
+    struct zwp_relative_pointer_manager_v1* zwp_relative_pointer_manager_v1,
+    void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_relative_pointer_manager_v1,
+                         user_data);
+}
+
+/** @ingroup iface_zwp_relative_pointer_manager_v1 */
+static inline void* zwp_relative_pointer_manager_v1_get_user_data(
+    struct zwp_relative_pointer_manager_v1* zwp_relative_pointer_manager_v1) {
+  return wl_proxy_get_user_data(
+      (struct wl_proxy*)zwp_relative_pointer_manager_v1);
+}
+
+static inline uint32_t zwp_relative_pointer_manager_v1_get_version(
+    struct zwp_relative_pointer_manager_v1* zwp_relative_pointer_manager_v1) {
+  return wl_proxy_get_version(
+      (struct wl_proxy*)zwp_relative_pointer_manager_v1);
+}
+
+/**
+ * @ingroup iface_zwp_relative_pointer_manager_v1
+ *
+ * Used by the client to notify the server that it will no longer use this
+ * relative pointer manager object.
+ */
+static inline void zwp_relative_pointer_manager_v1_destroy(
+    struct zwp_relative_pointer_manager_v1* zwp_relative_pointer_manager_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_relative_pointer_manager_v1,
+                   ZWP_RELATIVE_POINTER_MANAGER_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_relative_pointer_manager_v1);
+}
+
+/**
+ * @ingroup iface_zwp_relative_pointer_manager_v1
+ *
+ * Create a relative pointer interface given a wl_pointer object. See the
+ * wp_relative_pointer interface for more details.
+ */
+static inline struct zwp_relative_pointer_v1*
+zwp_relative_pointer_manager_v1_get_relative_pointer(
+    struct zwp_relative_pointer_manager_v1* zwp_relative_pointer_manager_v1,
+    struct wl_pointer* pointer) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor(
+      (struct wl_proxy*)zwp_relative_pointer_manager_v1,
+      ZWP_RELATIVE_POINTER_MANAGER_V1_GET_RELATIVE_POINTER,
+      &zwp_relative_pointer_v1_interface, NULL, pointer);
+
+  return (struct zwp_relative_pointer_v1*)id;
+}
+
+/**
+ * @ingroup iface_zwp_relative_pointer_v1
+ * @struct zwp_relative_pointer_v1_listener
+ */
+struct zwp_relative_pointer_v1_listener {
+  /**
+   * relative pointer motion
+   *
+   * Relative x/y pointer motion from the pointer of the seat
+   * associated with this object.
+   *
+   * A relative motion is in the same dimension as regular wl_pointer
+   * motion events, except they do not represent an absolute
+   * position. For example, moving a pointer from (x, y) to (x', y')
+   * would have the equivalent relative motion (x' - x, y' - y). If a
+   * pointer motion caused the absolute pointer position to be
+   * clipped by for example the edge of the monitor, the relative
+   * motion is unaffected by the clipping and will represent the
+   * unclipped motion.
+   *
+   * This event also contains non-accelerated motion deltas. The
+   * non-accelerated delta is, when applicable, the regular pointer
+   * motion delta as it was before having applied motion acceleration
+   * and other transformations such as normalization.
+   *
+   * Note that the non-accelerated delta does not represent 'raw'
+   * events as they were read from some device. Pointer motion
+   * acceleration is device- and configuration-specific and
+   * non-accelerated deltas and accelerated deltas may have the same
+   * value on some devices.
+   *
+   * Relative motions are not coupled to wl_pointer.motion events,
+   * and can be sent in combination with such events, but also
+   * independently. There may also be scenarios where
+   * wl_pointer.motion is sent, but there is no relative motion. The
+   * order of an absolute and relative motion event originating from
+   * the same physical motion is not guaranteed.
+   *
+   * If the client needs button events or focus state, it can receive
+   * them from a wl_pointer object of the same seat that the
+   * wp_relative_pointer object is associated with.
+   * @param utime_hi high 32 bits of a 64 bit timestamp with microsecond
+   * granularity
+   * @param utime_lo low 32 bits of a 64 bit timestamp with microsecond
+   * granularity
+   * @param dx the x component of the motion vector
+   * @param dy the y component of the motion vector
+   * @param dx_unaccel the x component of the unaccelerated motion vector
+   * @param dy_unaccel the y component of the unaccelerated motion vector
+   */
+  void (*relative_motion)(
+      void* data, struct zwp_relative_pointer_v1* zwp_relative_pointer_v1,
+      uint32_t utime_hi, uint32_t utime_lo, wl_fixed_t dx, wl_fixed_t dy,
+      wl_fixed_t dx_unaccel, wl_fixed_t dy_unaccel);
+};
+
+/**
+ * @ingroup iface_zwp_relative_pointer_v1
+ */
+static inline int zwp_relative_pointer_v1_add_listener(
+    struct zwp_relative_pointer_v1* zwp_relative_pointer_v1,
+    const struct zwp_relative_pointer_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)zwp_relative_pointer_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define ZWP_RELATIVE_POINTER_V1_DESTROY 0
+
+/**
+ * @ingroup iface_zwp_relative_pointer_v1
+ */
+#define ZWP_RELATIVE_POINTER_V1_RELATIVE_MOTION_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zwp_relative_pointer_v1
+ */
+#define ZWP_RELATIVE_POINTER_V1_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_relative_pointer_v1 */
+static inline void zwp_relative_pointer_v1_set_user_data(
+    struct zwp_relative_pointer_v1* zwp_relative_pointer_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zwp_relative_pointer_v1, user_data);
+}
+
+/** @ingroup iface_zwp_relative_pointer_v1 */
+static inline void* zwp_relative_pointer_v1_get_user_data(
+    struct zwp_relative_pointer_v1* zwp_relative_pointer_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zwp_relative_pointer_v1);
+}
+
+static inline uint32_t zwp_relative_pointer_v1_get_version(
+    struct zwp_relative_pointer_v1* zwp_relative_pointer_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zwp_relative_pointer_v1);
+}
+
+/**
+ * @ingroup iface_zwp_relative_pointer_v1
+ */
+static inline void zwp_relative_pointer_v1_destroy(
+    struct zwp_relative_pointer_v1* zwp_relative_pointer_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zwp_relative_pointer_v1,
+                   ZWP_RELATIVE_POINTER_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zwp_relative_pointer_v1);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/relative-pointer-unstable-v1-protocol.c b/widget/gtk/wayland/relative-pointer-unstable-v1-protocol.c
new file mode 100644
index 0000000000..3534686a3d
--- /dev/null
+++ b/widget/gtk/wayland/relative-pointer-unstable-v1-protocol.c
@@ -0,0 +1,69 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+/*
+ * Copyright © 2014      Jonas Ådahl
+ * Copyright © 2015      Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_pointer_interface;
+extern const struct wl_interface zwp_relative_pointer_v1_interface;
+#pragma GCC visibility pop
+
+static const struct wl_interface* relative_pointer_unstable_v1_types[] = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    &zwp_relative_pointer_v1_interface,
+    &wl_pointer_interface,
+};
+
+static const struct wl_message zwp_relative_pointer_manager_v1_requests[] = {
+    {"destroy", "", relative_pointer_unstable_v1_types + 0},
+    {"get_relative_pointer", "no", relative_pointer_unstable_v1_types + 6},
+};
+
+WL_EXPORT const struct wl_interface zwp_relative_pointer_manager_v1_interface =
+    {
+        "zwp_relative_pointer_manager_v1",        1, 2,
+        zwp_relative_pointer_manager_v1_requests, 0, NULL,
+};
+
+static const struct wl_message zwp_relative_pointer_v1_requests[] = {
+    {"destroy", "", relative_pointer_unstable_v1_types + 0},
+};
+
+static const struct wl_message zwp_relative_pointer_v1_events[] = {
+    {"relative_motion", "uuffff", relative_pointer_unstable_v1_types + 0},
+};
+
+WL_EXPORT const struct wl_interface zwp_relative_pointer_v1_interface = {
+    "zwp_relative_pointer_v1",        1, 1,
+    zwp_relative_pointer_v1_requests, 1, zwp_relative_pointer_v1_events,
+};
diff --git a/widget/gtk/wayland/va_drmcommon.h b/widget/gtk/wayland/va_drmcommon.h
new file mode 100644
index 0000000000..e16f244a46
--- /dev/null
+++ b/widget/gtk/wayland/va_drmcommon.h
@@ -0,0 +1,156 @@
+/*
+ * va_drmcommon.h - Common utilities for DRM-based drivers
+ *
+ * Copyright (c) 2012 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef VA_DRM_COMMON_H
+#define VA_DRM_COMMON_H
+
+#include <stdint.h>
+
+/** \brief DRM authentication type. */
+enum {
+  /** \brief Disconnected. */
+  VA_DRM_AUTH_NONE = 0,
+  /**
+   * \brief Connected. Authenticated with DRI1 protocol.
+   *
+   * @deprecated
+   * This is a deprecated authentication type. All DRI-based drivers have
+   * been migrated to use the DRI2 protocol. Newly written drivers shall
+   * use DRI2 protocol only, or a custom authentication means. e.g. opt
+   * for authenticating on the VA driver side, instead of libva side.
+   */
+  VA_DRM_AUTH_DRI1 = 1,
+  /**
+   * \brief Connected. Authenticated with DRI2 protocol.
+   *
+   * This is only useful to VA/X11 drivers. The libva-x11 library provides
+   * a helper function VA_DRI2Authenticate() for authenticating the
+   * connection. However, DRI2 conformant drivers don't need to call that
+   * function since authentication happens on the libva side, implicitly.
+   */
+  VA_DRM_AUTH_DRI2 = 2,
+  /**
+   * \brief Connected. Authenticated with some alternate raw protocol.
+   *
+   * This authentication mode is mainly used in non-VA/X11 drivers.
+   * Authentication happens through some alternative method, at the
+   * discretion of the VA driver implementation.
+   */
+  VA_DRM_AUTH_CUSTOM = 3
+};
+
+/** \brief Base DRM state. */
+struct drm_state {
+  /** \brief DRM connection descriptor. */
+  int fd;
+  /** \brief DRM authentication type. */
+  int auth_type;
+  /** \brief Reserved bytes for future use, must be zero */
+  int va_reserved[8];
+};
+
+/** \brief Kernel DRM buffer memory type.  */
+#define VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM 0x10000000
+/** \brief DRM PRIME memory type (old version)
+ *
+ * This supports only single objects with restricted memory layout.
+ * Used with VASurfaceAttribExternalBuffers.
+ */
+#define VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME 0x20000000
+/** \brief DRM PRIME memory type
+ *
+ * Used with VADRMPRIMESurfaceDescriptor.
+ */
+#define VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 0x40000000
+
+/**
+ * \brief External buffer descriptor for a DRM PRIME surface.
+ *
+ * For export, call vaExportSurfaceHandle() with mem_type set to
+ * VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 and pass a pointer to an
+ * instance of this structure to fill.
+ * If VA_EXPORT_SURFACE_SEPARATE_LAYERS is specified on export, each
+ * layer will contain exactly one plane.  For example, an NV12
+ * surface will be exported as two layers, one of DRM_FORMAT_R8 and
+ * one of DRM_FORMAT_GR88.
+ * If VA_EXPORT_SURFACE_COMPOSED_LAYERS is specified on export,
+ * there will be exactly one layer.
+ *
+ * For import, call vaCreateSurfaces() with the MemoryType attribute
+ * set to VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 and the
+ * ExternalBufferDescriptor attribute set to point to an array of
+ * num_surfaces instances of this structure.
+ * The number of planes which need to be provided for a given layer
+ * is dependent on both the format and the format modifier used for
+ * the objects containing it.  For example, the format DRM_FORMAT_RGBA
+ * normally requires one plane, but with the format modifier
+ * I915_FORMAT_MOD_Y_TILED_CCS it requires two planes - the first
+ * being the main data plane and the second containing the color
+ * control surface.
+ * Note that a given driver may only support a subset of possible
+ * representations of a particular format.  For example, it may only
+ * support NV12 surfaces when they are contained within a single DRM
+ * object, and therefore fail to create such surfaces if the two
+ * planes are in different DRM objects.
+ */
+typedef struct _VADRMPRIMESurfaceDescriptor {
+  /** Pixel format fourcc of the whole surface (VA_FOURCC_*). */
+  uint32_t fourcc;
+  /** Width of the surface in pixels. */
+  uint32_t width;
+  /** Height of the surface in pixels. */
+  uint32_t height;
+  /** Number of distinct DRM objects making up the surface. */
+  uint32_t num_objects;
+  /** Description of each object. */
+  struct {
+    /** DRM PRIME file descriptor for this object. */
+    int fd;
+    /** Total size of this object (may include regions which are
+     *  not part of the surface). */
+    uint32_t size;
+    /** Format modifier applied to this object. */
+    uint64_t drm_format_modifier;
+  } objects[4];
+  /** Number of layers making up the surface. */
+  uint32_t num_layers;
+  /** Description of each layer in the surface. */
+  struct {
+    /** DRM format fourcc of this layer (DRM_FOURCC_*). */
+    uint32_t drm_format;
+    /** Number of planes in this layer. */
+    uint32_t num_planes;
+    /** Index in the objects array of the object containing each
+     *  plane. */
+    uint32_t object_index[4];
+    /** Offset within the object of each plane. */
+    uint32_t offset[4];
+    /** Pitch of each plane. */
+    uint32_t pitch[4];
+  } layers[4];
+} VADRMPRIMESurfaceDescriptor;
+
+#endif /* VA_DRM_COMMON_H */
diff --git a/widget/gtk/wayland/viewporter-client-protocol.h b/widget/gtk/wayland/viewporter-client-protocol.h
new file mode 100644
index 0000000000..4c6c5bd910
--- /dev/null
+++ b/widget/gtk/wayland/viewporter-client-protocol.h
@@ -0,0 +1,392 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+#ifndef VIEWPORTER_CLIENT_PROTOCOL_H
+#define VIEWPORTER_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_viewporter The viewporter protocol
+ * @section page_ifaces_viewporter Interfaces
+ * - @subpage page_iface_wp_viewporter - surface cropping and scaling
+ * - @subpage page_iface_wp_viewport - crop and scale interface to a wl_surface
+ * @section page_copyright_viewporter Copyright
+ * <pre>
+ *
+ * Copyright © 2013-2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_surface;
+struct wp_viewport;
+struct wp_viewporter;
+
+/**
+ * @page page_iface_wp_viewporter wp_viewporter
+ * @section page_iface_wp_viewporter_desc Description
+ *
+ * The global interface exposing surface cropping and scaling
+ * capabilities is used to instantiate an interface extension for a
+ * wl_surface object. This extended interface will then allow
+ * cropping and scaling the surface contents, effectively
+ * disconnecting the direct relationship between the buffer and the
+ * surface size.
+ * @section page_iface_wp_viewporter_api API
+ * See @ref iface_wp_viewporter.
+ */
+/**
+ * @defgroup iface_wp_viewporter The wp_viewporter interface
+ *
+ * The global interface exposing surface cropping and scaling
+ * capabilities is used to instantiate an interface extension for a
+ * wl_surface object. This extended interface will then allow
+ * cropping and scaling the surface contents, effectively
+ * disconnecting the direct relationship between the buffer and the
+ * surface size.
+ */
+extern const struct wl_interface wp_viewporter_interface;
+/**
+ * @page page_iface_wp_viewport wp_viewport
+ * @section page_iface_wp_viewport_desc Description
+ *
+ * An additional interface to a wl_surface object, which allows the
+ * client to specify the cropping and scaling of the surface
+ * contents.
+ *
+ * This interface works with two concepts: the source rectangle (src_x,
+ * src_y, src_width, src_height), and the destination size (dst_width,
+ * dst_height). The contents of the source rectangle are scaled to the
+ * destination size, and content outside the source rectangle is ignored.
+ * This state is double-buffered, and is applied on the next
+ * wl_surface.commit.
+ *
+ * The two parts of crop and scale state are independent: the source
+ * rectangle, and the destination size. Initially both are unset, that
+ * is, no scaling is applied. The whole of the current wl_buffer is
+ * used as the source, and the surface size is as defined in
+ * wl_surface.attach.
+ *
+ * If the destination size is set, it causes the surface size to become
+ * dst_width, dst_height. The source (rectangle) is scaled to exactly
+ * this size. This overrides whatever the attached wl_buffer size is,
+ * unless the wl_buffer is NULL. If the wl_buffer is NULL, the surface
+ * has no content and therefore no size. Otherwise, the size is always
+ * at least 1x1 in surface local coordinates.
+ *
+ * If the source rectangle is set, it defines what area of the wl_buffer is
+ * taken as the source. If the source rectangle is set and the destination
+ * size is not set, then src_width and src_height must be integers, and the
+ * surface size becomes the source rectangle size. This results in cropping
+ * without scaling. If src_width or src_height are not integers and
+ * destination size is not set, the bad_size protocol error is raised when
+ * the surface state is applied.
+ *
+ * The coordinate transformations from buffer pixel coordinates up to
+ * the surface-local coordinates happen in the following order:
+ * 1. buffer_transform (wl_surface.set_buffer_transform)
+ * 2. buffer_scale (wl_surface.set_buffer_scale)
+ * 3. crop and scale (wp_viewport.set*)
+ * This means, that the source rectangle coordinates of crop and scale
+ * are given in the coordinates after the buffer transform and scale,
+ * i.e. in the coordinates that would be the surface-local coordinates
+ * if the crop and scale was not applied.
+ *
+ * If src_x or src_y are negative, the bad_value protocol error is raised.
+ * Otherwise, if the source rectangle is partially or completely outside of
+ * the non-NULL wl_buffer, then the out_of_buffer protocol error is raised
+ * when the surface state is applied. A NULL wl_buffer does not raise the
+ * out_of_buffer error.
+ *
+ * The x, y arguments of wl_surface.attach are applied as normal to
+ * the surface. They indicate how many pixels to remove from the
+ * surface size from the left and the top. In other words, they are
+ * still in the surface-local coordinate system, just like dst_width
+ * and dst_height are.
+ *
+ * If the wl_surface associated with the wp_viewport is destroyed,
+ * all wp_viewport requests except 'destroy' raise the protocol error
+ * no_surface.
+ *
+ * If the wp_viewport object is destroyed, the crop and scale
+ * state is removed from the wl_surface. The change will be applied
+ * on the next wl_surface.commit.
+ * @section page_iface_wp_viewport_api API
+ * See @ref iface_wp_viewport.
+ */
+/**
+ * @defgroup iface_wp_viewport The wp_viewport interface
+ *
+ * An additional interface to a wl_surface object, which allows the
+ * client to specify the cropping and scaling of the surface
+ * contents.
+ *
+ * This interface works with two concepts: the source rectangle (src_x,
+ * src_y, src_width, src_height), and the destination size (dst_width,
+ * dst_height). The contents of the source rectangle are scaled to the
+ * destination size, and content outside the source rectangle is ignored.
+ * This state is double-buffered, and is applied on the next
+ * wl_surface.commit.
+ *
+ * The two parts of crop and scale state are independent: the source
+ * rectangle, and the destination size. Initially both are unset, that
+ * is, no scaling is applied. The whole of the current wl_buffer is
+ * used as the source, and the surface size is as defined in
+ * wl_surface.attach.
+ *
+ * If the destination size is set, it causes the surface size to become
+ * dst_width, dst_height. The source (rectangle) is scaled to exactly
+ * this size. This overrides whatever the attached wl_buffer size is,
+ * unless the wl_buffer is NULL. If the wl_buffer is NULL, the surface
+ * has no content and therefore no size. Otherwise, the size is always
+ * at least 1x1 in surface local coordinates.
+ *
+ * If the source rectangle is set, it defines what area of the wl_buffer is
+ * taken as the source. If the source rectangle is set and the destination
+ * size is not set, then src_width and src_height must be integers, and the
+ * surface size becomes the source rectangle size. This results in cropping
+ * without scaling. If src_width or src_height are not integers and
+ * destination size is not set, the bad_size protocol error is raised when
+ * the surface state is applied.
+ *
+ * The coordinate transformations from buffer pixel coordinates up to
+ * the surface-local coordinates happen in the following order:
+ * 1. buffer_transform (wl_surface.set_buffer_transform)
+ * 2. buffer_scale (wl_surface.set_buffer_scale)
+ * 3. crop and scale (wp_viewport.set*)
+ * This means, that the source rectangle coordinates of crop and scale
+ * are given in the coordinates after the buffer transform and scale,
+ * i.e. in the coordinates that would be the surface-local coordinates
+ * if the crop and scale was not applied.
+ *
+ * If src_x or src_y are negative, the bad_value protocol error is raised.
+ * Otherwise, if the source rectangle is partially or completely outside of
+ * the non-NULL wl_buffer, then the out_of_buffer protocol error is raised
+ * when the surface state is applied. A NULL wl_buffer does not raise the
+ * out_of_buffer error.
+ *
+ * The x, y arguments of wl_surface.attach are applied as normal to
+ * the surface. They indicate how many pixels to remove from the
+ * surface size from the left and the top. In other words, they are
+ * still in the surface-local coordinate system, just like dst_width
+ * and dst_height are.
+ *
+ * If the wl_surface associated with the wp_viewport is destroyed,
+ * all wp_viewport requests except 'destroy' raise the protocol error
+ * no_surface.
+ *
+ * If the wp_viewport object is destroyed, the crop and scale
+ * state is removed from the wl_surface. The change will be applied
+ * on the next wl_surface.commit.
+ */
+extern const struct wl_interface wp_viewport_interface;
+
+#ifndef WP_VIEWPORTER_ERROR_ENUM
+#  define WP_VIEWPORTER_ERROR_ENUM
+enum wp_viewporter_error {
+  /**
+   * the surface already has a viewport object associated
+   */
+  WP_VIEWPORTER_ERROR_VIEWPORT_EXISTS = 0,
+};
+#endif /* WP_VIEWPORTER_ERROR_ENUM */
+
+#define WP_VIEWPORTER_DESTROY 0
+#define WP_VIEWPORTER_GET_VIEWPORT 1
+
+/**
+ * @ingroup iface_wp_viewporter
+ */
+#define WP_VIEWPORTER_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_wp_viewporter
+ */
+#define WP_VIEWPORTER_GET_VIEWPORT_SINCE_VERSION 1
+
+/** @ingroup iface_wp_viewporter */
+static inline void wp_viewporter_set_user_data(
+    struct wp_viewporter* wp_viewporter, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)wp_viewporter, user_data);
+}
+
+/** @ingroup iface_wp_viewporter */
+static inline void* wp_viewporter_get_user_data(
+    struct wp_viewporter* wp_viewporter) {
+  return wl_proxy_get_user_data((struct wl_proxy*)wp_viewporter);
+}
+
+static inline uint32_t wp_viewporter_get_version(
+    struct wp_viewporter* wp_viewporter) {
+  return wl_proxy_get_version((struct wl_proxy*)wp_viewporter);
+}
+
+/**
+ * @ingroup iface_wp_viewporter
+ *
+ * Informs the server that the client will not be using this
+ * protocol object anymore. This does not affect any other objects,
+ * wp_viewport objects included.
+ */
+static inline void wp_viewporter_destroy(struct wp_viewporter* wp_viewporter) {
+  wl_proxy_marshal((struct wl_proxy*)wp_viewporter, WP_VIEWPORTER_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)wp_viewporter);
+}
+
+/**
+ * @ingroup iface_wp_viewporter
+ *
+ * Instantiate an interface extension for the given wl_surface to
+ * crop and scale its content. If the given wl_surface already has
+ * a wp_viewport object associated, the viewport_exists
+ * protocol error is raised.
+ */
+static inline struct wp_viewport* wp_viewporter_get_viewport(
+    struct wp_viewporter* wp_viewporter, struct wl_surface* surface) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor((struct wl_proxy*)wp_viewporter,
+                                    WP_VIEWPORTER_GET_VIEWPORT,
+                                    &wp_viewport_interface, NULL, surface);
+
+  return (struct wp_viewport*)id;
+}
+
+#ifndef WP_VIEWPORT_ERROR_ENUM
+#  define WP_VIEWPORT_ERROR_ENUM
+enum wp_viewport_error {
+  /**
+   * negative or zero values in width or height
+   */
+  WP_VIEWPORT_ERROR_BAD_VALUE = 0,
+  /**
+   * destination size is not integer
+   */
+  WP_VIEWPORT_ERROR_BAD_SIZE = 1,
+  /**
+   * source rectangle extends outside of the content area
+   */
+  WP_VIEWPORT_ERROR_OUT_OF_BUFFER = 2,
+  /**
+   * the wl_surface was destroyed
+   */
+  WP_VIEWPORT_ERROR_NO_SURFACE = 3,
+};
+#endif /* WP_VIEWPORT_ERROR_ENUM */
+
+#define WP_VIEWPORT_DESTROY 0
+#define WP_VIEWPORT_SET_SOURCE 1
+#define WP_VIEWPORT_SET_DESTINATION 2
+
+/**
+ * @ingroup iface_wp_viewport
+ */
+#define WP_VIEWPORT_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_wp_viewport
+ */
+#define WP_VIEWPORT_SET_SOURCE_SINCE_VERSION 1
+/**
+ * @ingroup iface_wp_viewport
+ */
+#define WP_VIEWPORT_SET_DESTINATION_SINCE_VERSION 1
+
+/** @ingroup iface_wp_viewport */
+static inline void wp_viewport_set_user_data(struct wp_viewport* wp_viewport,
+                                             void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)wp_viewport, user_data);
+}
+
+/** @ingroup iface_wp_viewport */
+static inline void* wp_viewport_get_user_data(struct wp_viewport* wp_viewport) {
+  return wl_proxy_get_user_data((struct wl_proxy*)wp_viewport);
+}
+
+static inline uint32_t wp_viewport_get_version(
+    struct wp_viewport* wp_viewport) {
+  return wl_proxy_get_version((struct wl_proxy*)wp_viewport);
+}
+
+/**
+ * @ingroup iface_wp_viewport
+ *
+ * The associated wl_surface's crop and scale state is removed.
+ * The change is applied on the next wl_surface.commit.
+ */
+static inline void wp_viewport_destroy(struct wp_viewport* wp_viewport) {
+  wl_proxy_marshal((struct wl_proxy*)wp_viewport, WP_VIEWPORT_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)wp_viewport);
+}
+
+/**
+ * @ingroup iface_wp_viewport
+ *
+ * Set the source rectangle of the associated wl_surface. See
+ * wp_viewport for the description, and relation to the wl_buffer
+ * size.
+ *
+ * If all of x, y, width and height are -1.0, the source rectangle is
+ * unset instead. Any other set of values where width or height are zero
+ * or negative, or x or y are negative, raise the bad_value protocol
+ * error.
+ *
+ * The crop and scale state is double-buffered state, and will be
+ * applied on the next wl_surface.commit.
+ */
+static inline void wp_viewport_set_source(struct wp_viewport* wp_viewport,
+                                          wl_fixed_t x, wl_fixed_t y,
+                                          wl_fixed_t width, wl_fixed_t height) {
+  wl_proxy_marshal((struct wl_proxy*)wp_viewport, WP_VIEWPORT_SET_SOURCE, x, y,
+                   width, height);
+}
+
+/**
+ * @ingroup iface_wp_viewport
+ *
+ * Set the destination size of the associated wl_surface. See
+ * wp_viewport for the description, and relation to the wl_buffer
+ * size.
+ *
+ * If width is -1 and height is -1, the destination size is unset
+ * instead. Any other pair of values for width and height that
+ * contains zero or negative values raises the bad_value protocol
+ * error.
+ *
+ * The crop and scale state is double-buffered state, and will be
+ * applied on the next wl_surface.commit.
+ */
+static inline void wp_viewport_set_destination(struct wp_viewport* wp_viewport,
+                                               int32_t width, int32_t height) {
+  wl_proxy_marshal((struct wl_proxy*)wp_viewport, WP_VIEWPORT_SET_DESTINATION,
+                   width, height);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/viewporter-protocol.c b/widget/gtk/wayland/viewporter-protocol.c
new file mode 100644
index 0000000000..06b7901426
--- /dev/null
+++ b/widget/gtk/wayland/viewporter-protocol.c
@@ -0,0 +1,56 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+/*
+ * Copyright © 2013-2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface wp_viewport_interface;
+#pragma GCC visibility pop
+
+static const struct wl_interface* viewporter_types[] = {
+    NULL, NULL, NULL, NULL, &wp_viewport_interface, &wl_surface_interface,
+};
+
+static const struct wl_message wp_viewporter_requests[] = {
+    {"destroy", "", viewporter_types + 0},
+    {"get_viewport", "no", viewporter_types + 4},
+};
+
+const struct wl_interface wp_viewporter_interface = {
+    "wp_viewporter", 1, 2, wp_viewporter_requests, 0, NULL,
+};
+
+static const struct wl_message wp_viewport_requests[] = {
+    {"destroy", "", viewporter_types + 0},
+    {"set_source", "ffff", viewporter_types + 0},
+    {"set_destination", "ii", viewporter_types + 0},
+};
+
+const struct wl_interface wp_viewport_interface = {
+    "wp_viewport", 1, 3, wp_viewport_requests, 0, NULL,
+};
diff --git a/widget/gtk/wayland/xdg-activation-v1-client-protocol.h b/widget/gtk/wayland/xdg-activation-v1-client-protocol.h
new file mode 100644
index 0000000000..9bebcb6ec2
--- /dev/null
+++ b/widget/gtk/wayland/xdg-activation-v1-client-protocol.h
@@ -0,0 +1,409 @@
+/* Generated by wayland-scanner 1.19.0 */
+
+#ifndef XDG_ACTIVATION_V1_CLIENT_PROTOCOL_H
+#define XDG_ACTIVATION_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_activation_v1 The xdg_activation_v1 protocol
+ * Protocol for requesting activation of surfaces
+ *
+ * @section page_desc_xdg_activation_v1 Description
+ *
+ * The way for a client to pass focus to another toplevel is as follows.
+ *
+ * The client that intends to activate another toplevel uses the
+ * xdg_activation_v1.get_activation_token request to get an activation token.
+ * This token is then forwarded to the client, which is supposed to activate
+ * one of its surfaces, through a separate band of communication.
+ *
+ * One established way of doing this is through the XDG_ACTIVATION_TOKEN
+ * environment variable of a newly launched child process. The child process
+ * should unset the environment variable again right after reading it out in
+ * order to avoid propagating it to other child processes.
+ *
+ * Another established way exists for Applications implementing the D-Bus
+ * interface org.freedesktop.Application, which should get their token under
+ * XDG_ACTIVATION_TOKEN on their platform_data.
+ *
+ * In general activation tokens may be transferred across clients through
+ * means not described in this protocol.
+ *
+ * The client to be activated will then pass the token
+ * it received to the xdg_activation_v1.activate request. The compositor can
+ * then use this token to decide how to react to the activation request.
+ *
+ * The token the activating client gets may be ineffective either already at
+ * the time it receives it, for example if it was not focused, for focus
+ * stealing prevention. The activating client will have no way to discover
+ * the validity of the token, and may still forward it to the to be activated
+ * client.
+ *
+ * The created activation token may optionally get information attached to it
+ * that can be used by the compositor to identify the application that we
+ * intend to activate. This can for example be used to display a visual hint
+ * about what application is being started.
+ *
+ * Warning! The protocol described in this file is currently in the testing
+ * phase. Backward compatible changes may be added together with the
+ * corresponding interface version bump. Backward incompatible changes can
+ * only be done by creating a new major version of the extension.
+ *
+ * @section page_ifaces_xdg_activation_v1 Interfaces
+ * - @subpage page_iface_xdg_activation_v1 - interface for activating surfaces
+ * - @subpage page_iface_xdg_activation_token_v1 - an exported activation handle
+ * @section page_copyright_xdg_activation_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2020 Aleix Pol Gonzalez <aleixpol@kde.org>
+ * Copyright © 2020 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_seat;
+struct wl_surface;
+struct xdg_activation_token_v1;
+struct xdg_activation_v1;
+
+#ifndef XDG_ACTIVATION_V1_INTERFACE
+#  define XDG_ACTIVATION_V1_INTERFACE
+/**
+ * @page page_iface_xdg_activation_v1 xdg_activation_v1
+ * @section page_iface_xdg_activation_v1_desc Description
+ *
+ * A global interface used for informing the compositor about applications
+ * being activated or started, or for applications to request to be
+ * activated.
+ * @section page_iface_xdg_activation_v1_api API
+ * See @ref iface_xdg_activation_v1.
+ */
+/**
+ * @defgroup iface_xdg_activation_v1 The xdg_activation_v1 interface
+ *
+ * A global interface used for informing the compositor about applications
+ * being activated or started, or for applications to request to be
+ * activated.
+ */
+extern const struct wl_interface xdg_activation_v1_interface;
+#endif
+#ifndef XDG_ACTIVATION_TOKEN_V1_INTERFACE
+#  define XDG_ACTIVATION_TOKEN_V1_INTERFACE
+/**
+ * @page page_iface_xdg_activation_token_v1 xdg_activation_token_v1
+ * @section page_iface_xdg_activation_token_v1_desc Description
+ *
+ * An object for setting up a token and receiving a token handle that can
+ * be passed as an activation token to another client.
+ *
+ * The object is created using the xdg_activation_v1.get_activation_token
+ * request. This object should then be populated with the app_id, surface
+ * and serial information and committed. The compositor shall then issue a
+ * done event with the token. In case the request's parameters are invalid,
+ * the compositor will provide an invalid token.
+ * @section page_iface_xdg_activation_token_v1_api API
+ * See @ref iface_xdg_activation_token_v1.
+ */
+/**
+ * @defgroup iface_xdg_activation_token_v1 The xdg_activation_token_v1 interface
+ *
+ * An object for setting up a token and receiving a token handle that can
+ * be passed as an activation token to another client.
+ *
+ * The object is created using the xdg_activation_v1.get_activation_token
+ * request. This object should then be populated with the app_id, surface
+ * and serial information and committed. The compositor shall then issue a
+ * done event with the token. In case the request's parameters are invalid,
+ * the compositor will provide an invalid token.
+ */
+extern const struct wl_interface xdg_activation_token_v1_interface;
+#endif
+
+#define XDG_ACTIVATION_V1_DESTROY 0
+#define XDG_ACTIVATION_V1_GET_ACTIVATION_TOKEN 1
+#define XDG_ACTIVATION_V1_ACTIVATE 2
+
+/**
+ * @ingroup iface_xdg_activation_v1
+ */
+#define XDG_ACTIVATION_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_activation_v1
+ */
+#define XDG_ACTIVATION_V1_GET_ACTIVATION_TOKEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_activation_v1
+ */
+#define XDG_ACTIVATION_V1_ACTIVATE_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_activation_v1 */
+static inline void xdg_activation_v1_set_user_data(
+    struct xdg_activation_v1* xdg_activation_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)xdg_activation_v1, user_data);
+}
+
+/** @ingroup iface_xdg_activation_v1 */
+static inline void* xdg_activation_v1_get_user_data(
+    struct xdg_activation_v1* xdg_activation_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)xdg_activation_v1);
+}
+
+static inline uint32_t xdg_activation_v1_get_version(
+    struct xdg_activation_v1* xdg_activation_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)xdg_activation_v1);
+}
+
+/**
+ * @ingroup iface_xdg_activation_v1
+ *
+ * Notify the compositor that the xdg_activation object will no longer be
+ * used.
+ *
+ * The child objects created via this interface are unaffected and should
+ * be destroyed separately.
+ */
+static inline void xdg_activation_v1_destroy(
+    struct xdg_activation_v1* xdg_activation_v1) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_v1,
+                   XDG_ACTIVATION_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)xdg_activation_v1);
+}
+
+/**
+ * @ingroup iface_xdg_activation_v1
+ *
+ * Creates an xdg_activation_token_v1 object that will provide
+ * the initiating client with a unique token for this activation. This
+ * token should be offered to the clients to be activated.
+ */
+static inline struct xdg_activation_token_v1*
+xdg_activation_v1_get_activation_token(
+    struct xdg_activation_v1* xdg_activation_v1) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor((struct wl_proxy*)xdg_activation_v1,
+                                    XDG_ACTIVATION_V1_GET_ACTIVATION_TOKEN,
+                                    &xdg_activation_token_v1_interface, NULL);
+
+  return (struct xdg_activation_token_v1*)id;
+}
+
+/**
+ * @ingroup iface_xdg_activation_v1
+ *
+ * Requests surface activation. It's up to the compositor to display
+ * this information as desired, for example by placing the surface above
+ * the rest.
+ *
+ * The compositor may know who requested this by checking the activation
+ * token and might decide not to follow through with the activation if it's
+ * considered unwanted.
+ *
+ * Compositors can ignore unknown activation tokens when an invalid
+ * token is passed.
+ */
+static inline void xdg_activation_v1_activate(
+    struct xdg_activation_v1* xdg_activation_v1, const char* token,
+    struct wl_surface* surface) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_v1,
+                   XDG_ACTIVATION_V1_ACTIVATE, token, surface);
+}
+
+#ifndef XDG_ACTIVATION_TOKEN_V1_ERROR_ENUM
+#  define XDG_ACTIVATION_TOKEN_V1_ERROR_ENUM
+enum xdg_activation_token_v1_error {
+  /**
+   * The token has already been used previously
+   */
+  XDG_ACTIVATION_TOKEN_V1_ERROR_ALREADY_USED = 0,
+};
+#endif /* XDG_ACTIVATION_TOKEN_V1_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ * @struct xdg_activation_token_v1_listener
+ */
+struct xdg_activation_token_v1_listener {
+  /**
+   * the exported activation token
+   *
+   * The 'done' event contains the unique token of this activation
+   * request and notifies that the provider is done.
+   * @param token the exported activation token
+   */
+  void (*done)(void* data,
+               struct xdg_activation_token_v1* xdg_activation_token_v1,
+               const char* token);
+};
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+static inline int xdg_activation_token_v1_add_listener(
+    struct xdg_activation_token_v1* xdg_activation_token_v1,
+    const struct xdg_activation_token_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)xdg_activation_token_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define XDG_ACTIVATION_TOKEN_V1_SET_SERIAL 0
+#define XDG_ACTIVATION_TOKEN_V1_SET_APP_ID 1
+#define XDG_ACTIVATION_TOKEN_V1_SET_SURFACE 2
+#define XDG_ACTIVATION_TOKEN_V1_COMMIT 3
+#define XDG_ACTIVATION_TOKEN_V1_DESTROY 4
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+#define XDG_ACTIVATION_TOKEN_V1_DONE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+#define XDG_ACTIVATION_TOKEN_V1_SET_SERIAL_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+#define XDG_ACTIVATION_TOKEN_V1_SET_APP_ID_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+#define XDG_ACTIVATION_TOKEN_V1_SET_SURFACE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+#define XDG_ACTIVATION_TOKEN_V1_COMMIT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ */
+#define XDG_ACTIVATION_TOKEN_V1_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_activation_token_v1 */
+static inline void xdg_activation_token_v1_set_user_data(
+    struct xdg_activation_token_v1* xdg_activation_token_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)xdg_activation_token_v1, user_data);
+}
+
+/** @ingroup iface_xdg_activation_token_v1 */
+static inline void* xdg_activation_token_v1_get_user_data(
+    struct xdg_activation_token_v1* xdg_activation_token_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)xdg_activation_token_v1);
+}
+
+static inline uint32_t xdg_activation_token_v1_get_version(
+    struct xdg_activation_token_v1* xdg_activation_token_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)xdg_activation_token_v1);
+}
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ *
+ * Provides information about the seat and serial event that requested the
+ * token.
+ *
+ * The serial can come from an input or focus event. For instance, if a
+ * click triggers the launch of a third-party client, the launcher client
+ * should send a set_serial request with the serial and seat from the
+ * wl_pointer.button event.
+ *
+ * Some compositors might refuse to activate toplevels when the token
+ * doesn't have a valid and recent enough event serial.
+ *
+ * Must be sent before commit. This information is optional.
+ */
+static inline void xdg_activation_token_v1_set_serial(
+    struct xdg_activation_token_v1* xdg_activation_token_v1, uint32_t serial,
+    struct wl_seat* seat) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_token_v1,
+                   XDG_ACTIVATION_TOKEN_V1_SET_SERIAL, serial, seat);
+}
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ *
+ * The requesting client can specify an app_id to associate the token
+ * being created with it.
+ *
+ * Must be sent before commit. This information is optional.
+ */
+static inline void xdg_activation_token_v1_set_app_id(
+    struct xdg_activation_token_v1* xdg_activation_token_v1,
+    const char* app_id) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_token_v1,
+                   XDG_ACTIVATION_TOKEN_V1_SET_APP_ID, app_id);
+}
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ *
+ * This request sets the surface requesting the activation. Note, this is
+ * different from the surface that will be activated.
+ *
+ * Some compositors might refuse to activate toplevels when the token
+ * doesn't have a requesting surface.
+ *
+ * Must be sent before commit. This information is optional.
+ */
+static inline void xdg_activation_token_v1_set_surface(
+    struct xdg_activation_token_v1* xdg_activation_token_v1,
+    struct wl_surface* surface) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_token_v1,
+                   XDG_ACTIVATION_TOKEN_V1_SET_SURFACE, surface);
+}
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ *
+ * Requests an activation token based on the different parameters that
+ * have been offered through set_serial, set_surface and set_app_id.
+ */
+static inline void xdg_activation_token_v1_commit(
+    struct xdg_activation_token_v1* xdg_activation_token_v1) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_token_v1,
+                   XDG_ACTIVATION_TOKEN_V1_COMMIT);
+}
+
+/**
+ * @ingroup iface_xdg_activation_token_v1
+ *
+ * Notify the compositor that the xdg_activation_token_v1 object will no
+ * longer be used.
+ */
+static inline void xdg_activation_token_v1_destroy(
+    struct xdg_activation_token_v1* xdg_activation_token_v1) {
+  wl_proxy_marshal((struct wl_proxy*)xdg_activation_token_v1,
+                   XDG_ACTIVATION_TOKEN_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)xdg_activation_token_v1);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/xdg-activation-v1-protocol.c b/widget/gtk/wayland/xdg-activation-v1-protocol.c
new file mode 100644
index 0000000000..1fad6dbf97
--- /dev/null
+++ b/widget/gtk/wayland/xdg-activation-v1-protocol.c
@@ -0,0 +1,82 @@
+/* Generated by wayland-scanner 1.19.0 */
+
+/*
+ * Copyright © 2020 Aleix Pol Gonzalez <aleixpol@kde.org>
+ * Copyright © 2020 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+#  define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#  define WL_PRIVATE __attribute__((visibility("hidden")))
+#else
+#  define WL_PRIVATE
+#endif
+
+#pragma GCC visibility push(default)
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+#pragma GCC visibility pop
+extern const struct wl_interface xdg_activation_token_v1_interface;
+
+static const struct wl_interface* xdg_activation_v1_types[] = {
+    NULL,
+    &xdg_activation_token_v1_interface,
+    NULL,
+    &wl_surface_interface,
+    NULL,
+    &wl_seat_interface,
+    &wl_surface_interface,
+};
+
+static const struct wl_message xdg_activation_v1_requests[] = {
+    {"destroy", "", xdg_activation_v1_types + 0},
+    {"get_activation_token", "n", xdg_activation_v1_types + 1},
+    {"activate", "so", xdg_activation_v1_types + 2},
+};
+
+WL_PRIVATE const struct wl_interface xdg_activation_v1_interface = {
+    "xdg_activation_v1", 1, 3, xdg_activation_v1_requests, 0, NULL,
+};
+
+static const struct wl_message xdg_activation_token_v1_requests[] = {
+    {"set_serial", "uo", xdg_activation_v1_types + 4},
+    {"set_app_id", "s", xdg_activation_v1_types + 0},
+    {"set_surface", "o", xdg_activation_v1_types + 6},
+    {"commit", "", xdg_activation_v1_types + 0},
+    {"destroy", "", xdg_activation_v1_types + 0},
+};
+
+static const struct wl_message xdg_activation_token_v1_events[] = {
+    {"done", "s", xdg_activation_v1_types + 0},
+};
+
+WL_PRIVATE const struct wl_interface xdg_activation_token_v1_interface = {
+    "xdg_activation_token_v1",        1, 5,
+    xdg_activation_token_v1_requests, 1, xdg_activation_token_v1_events,
+};
diff --git a/widget/gtk/wayland/xdg-output-unstable-v1-client-protocol.h b/widget/gtk/wayland/xdg-output-unstable-v1-client-protocol.h
new file mode 100644
index 0000000000..432057ccef
--- /dev/null
+++ b/widget/gtk/wayland/xdg-output-unstable-v1-client-protocol.h
@@ -0,0 +1,392 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+#ifndef XDG_OUTPUT_UNSTABLE_V1_CLIENT_PROTOCOL_H
+#define XDG_OUTPUT_UNSTABLE_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_output_unstable_v1 The xdg_output_unstable_v1 protocol
+ * Protocol to describe output regions
+ *
+ * @section page_desc_xdg_output_unstable_v1 Description
+ *
+ * This protocol aims at describing outputs in a way which is more in line
+ * with the concept of an output on desktop oriented systems.
+ *
+ * Some information are more specific to the concept of an output for
+ * a desktop oriented system and may not make sense in other applications,
+ * such as IVI systems for example.
+ *
+ * Typically, the global compositor space on a desktop system is made of
+ * a contiguous or overlapping set of rectangular regions.
+ *
+ * Some of the information provided in this protocol might be identical
+ * to their counterparts already available from wl_output, in which case
+ * the information provided by this protocol should be preferred to their
+ * equivalent in wl_output. The goal is to move the desktop specific
+ * concepts (such as output location within the global compositor space,
+ * the connector name and types, etc.) out of the core wl_output protocol.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible
+ * changes may be added together with the corresponding interface
+ * version bump.
+ * Backward incompatible changes are done by bumping the version
+ * number in the protocol and interface names and resetting the
+ * interface version. Once the protocol is to be declared stable,
+ * the 'z' prefix and the version number in the protocol and
+ * interface names are removed and the interface version number is
+ * reset.
+ *
+ * @section page_ifaces_xdg_output_unstable_v1 Interfaces
+ * - @subpage page_iface_zxdg_output_manager_v1 - manage xdg_output objects
+ * - @subpage page_iface_zxdg_output_v1 - compositor logical output region
+ * @section page_copyright_xdg_output_unstable_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_output;
+struct zxdg_output_manager_v1;
+struct zxdg_output_v1;
+
+/**
+ * @page page_iface_zxdg_output_manager_v1 zxdg_output_manager_v1
+ * @section page_iface_zxdg_output_manager_v1_desc Description
+ *
+ * A global factory interface for xdg_output objects.
+ * @section page_iface_zxdg_output_manager_v1_api API
+ * See @ref iface_zxdg_output_manager_v1.
+ */
+/**
+ * @defgroup iface_zxdg_output_manager_v1 The zxdg_output_manager_v1 interface
+ *
+ * A global factory interface for xdg_output objects.
+ */
+extern const struct wl_interface zxdg_output_manager_v1_interface;
+/**
+ * @page page_iface_zxdg_output_v1 zxdg_output_v1
+ * @section page_iface_zxdg_output_v1_desc Description
+ *
+ * An xdg_output describes part of the compositor geometry.
+ *
+ * This typically corresponds to a monitor that displays part of the
+ * compositor space.
+ *
+ * For objects version 3 onwards, after all xdg_output properties have been
+ * sent (when the object is created and when properties are updated), a
+ * wl_output.done event is sent. This allows changes to the output
+ * properties to be seen as atomic, even if they happen via multiple events.
+ * @section page_iface_zxdg_output_v1_api API
+ * See @ref iface_zxdg_output_v1.
+ */
+/**
+ * @defgroup iface_zxdg_output_v1 The zxdg_output_v1 interface
+ *
+ * An xdg_output describes part of the compositor geometry.
+ *
+ * This typically corresponds to a monitor that displays part of the
+ * compositor space.
+ *
+ * For objects version 3 onwards, after all xdg_output properties have been
+ * sent (when the object is created and when properties are updated), a
+ * wl_output.done event is sent. This allows changes to the output
+ * properties to be seen as atomic, even if they happen via multiple events.
+ */
+extern const struct wl_interface zxdg_output_v1_interface;
+
+#define ZXDG_OUTPUT_MANAGER_V1_DESTROY 0
+#define ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT 1
+
+/**
+ * @ingroup iface_zxdg_output_manager_v1
+ */
+#define ZXDG_OUTPUT_MANAGER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_output_manager_v1
+ */
+#define ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_output_manager_v1 */
+static inline void zxdg_output_manager_v1_set_user_data(
+    struct zxdg_output_manager_v1* zxdg_output_manager_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zxdg_output_manager_v1, user_data);
+}
+
+/** @ingroup iface_zxdg_output_manager_v1 */
+static inline void* zxdg_output_manager_v1_get_user_data(
+    struct zxdg_output_manager_v1* zxdg_output_manager_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zxdg_output_manager_v1);
+}
+
+static inline uint32_t zxdg_output_manager_v1_get_version(
+    struct zxdg_output_manager_v1* zxdg_output_manager_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zxdg_output_manager_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_output_manager_v1
+ *
+ * Using this request a client can tell the server that it is not
+ * going to use the xdg_output_manager object anymore.
+ *
+ * Any objects already created through this instance are not affected.
+ */
+static inline void zxdg_output_manager_v1_destroy(
+    struct zxdg_output_manager_v1* zxdg_output_manager_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zxdg_output_manager_v1,
+                   ZXDG_OUTPUT_MANAGER_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zxdg_output_manager_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_output_manager_v1
+ *
+ * This creates a new xdg_output object for the given wl_output.
+ */
+static inline struct zxdg_output_v1* zxdg_output_manager_v1_get_xdg_output(
+    struct zxdg_output_manager_v1* zxdg_output_manager_v1,
+    struct wl_output* output) {
+  struct wl_proxy* id;
+
+  id = wl_proxy_marshal_constructor((struct wl_proxy*)zxdg_output_manager_v1,
+                                    ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT,
+                                    &zxdg_output_v1_interface, NULL, output);
+
+  return (struct zxdg_output_v1*)id;
+}
+
+/**
+ * @ingroup iface_zxdg_output_v1
+ * @struct zxdg_output_v1_listener
+ */
+struct zxdg_output_v1_listener {
+  /**
+   * position of the output within the global compositor space
+   *
+   * The position event describes the location of the wl_output
+   * within the global compositor space.
+   *
+   * The logical_position event is sent after creating an xdg_output
+   * (see xdg_output_manager.get_xdg_output) and whenever the
+   * location of the output changes within the global compositor
+   * space.
+   * @param x x position within the global compositor space
+   * @param y y position within the global compositor space
+   */
+  void (*logical_position)(void* data, struct zxdg_output_v1* zxdg_output_v1,
+                           int32_t x, int32_t y);
+  /**
+   * size of the output in the global compositor space
+   *
+   * The logical_size event describes the size of the output in the
+   * global compositor space.
+   *
+   * For example, a surface without any buffer scale, transformation
+   * nor rotation set, with the size matching the logical_size will
+   * have the same size as the corresponding output when displayed.
+   *
+   * Most regular Wayland clients should not pay attention to the
+   * logical size and would rather rely on xdg_shell interfaces.
+   *
+   * Some clients such as Xwayland, however, need this to configure
+   * their surfaces in the global compositor space as the compositor
+   * may apply a different scale from what is advertised by the
+   * output scaling property (to achieve fractional scaling, for
+   * example).
+   *
+   * For example, for a wl_output mode 3840×2160 and a scale factor
+   * 2:
+   *
+   * - A compositor not scaling the surface buffers will advertise a
+   * logical size of 3840×2160,
+   *
+   * - A compositor automatically scaling the surface buffers will
+   * advertise a logical size of 1920×1080,
+   *
+   * - A compositor using a fractional scale of 1.5 will advertise a
+   * logical size to 2560×1620.
+   *
+   * For example, for a wl_output mode 1920×1080 and a 90 degree
+   * rotation, the compositor will advertise a logical size of
+   * 1080x1920.
+   *
+   * The logical_size event is sent after creating an xdg_output (see
+   * xdg_output_manager.get_xdg_output) and whenever the logical size
+   * of the output changes, either as a result of a change in the
+   * applied scale or because of a change in the corresponding output
+   * mode(see wl_output.mode) or transform (see wl_output.transform).
+   * @param width width in global compositor space
+   * @param height height in global compositor space
+   */
+  void (*logical_size)(void* data, struct zxdg_output_v1* zxdg_output_v1,
+                       int32_t width, int32_t height);
+  /**
+   * all information about the output have been sent
+   *
+   * This event is sent after all other properties of an xdg_output
+   * have been sent.
+   *
+   * This allows changes to the xdg_output properties to be seen as
+   * atomic, even if they happen via multiple events.
+   *
+   * For objects version 3 onwards, this event is deprecated.
+   * Compositors are not required to send it anymore and must send
+   * wl_output.done instead.
+   */
+  void (*done)(void* data, struct zxdg_output_v1* zxdg_output_v1);
+  /**
+   * name of this output
+   *
+   * Many compositors will assign names to their outputs, show them
+   * to the user, allow them to be configured by name, etc. The
+   * client may wish to know this name as well to offer the user
+   * similar behaviors.
+   *
+   * The naming convention is compositor defined, but limited to
+   * alphanumeric characters and dashes (-). Each name is unique
+   * among all wl_output globals, but if a wl_output global is
+   * destroyed the same name may be reused later. The names will also
+   * remain consistent across sessions with the same hardware and
+   * software configuration.
+   *
+   * Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc.
+   * However, do not assume that the name is a reflection of an
+   * underlying DRM connector, X11 connection, etc.
+   *
+   * The name event is sent after creating an xdg_output (see
+   * xdg_output_manager.get_xdg_output). This event is only sent once
+   * per xdg_output, and the name does not change over the lifetime
+   * of the wl_output global.
+   * @param name output name
+   * @since 2
+   */
+  void (*name)(void* data, struct zxdg_output_v1* zxdg_output_v1,
+               const char* name);
+  /**
+   * human-readable description of this output
+   *
+   * Many compositors can produce human-readable descriptions of
+   * their outputs. The client may wish to know this description as
+   * well, to communicate the user for various purposes.
+   *
+   * The description is a UTF-8 string with no convention defined for
+   * its contents. Examples might include 'Foocorp 11" Display' or
+   * 'Virtual X11 output via :1'.
+   *
+   * The description event is sent after creating an xdg_output (see
+   * xdg_output_manager.get_xdg_output) and whenever the description
+   * changes. The description is optional, and may not be sent at
+   * all.
+   *
+   * For objects of version 2 and lower, this event is only sent once
+   * per xdg_output, and the description does not change over the
+   * lifetime of the wl_output global.
+   * @param description output description
+   * @since 2
+   */
+  void (*description)(void* data, struct zxdg_output_v1* zxdg_output_v1,
+                      const char* description);
+};
+
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+static inline int zxdg_output_v1_add_listener(
+    struct zxdg_output_v1* zxdg_output_v1,
+    const struct zxdg_output_v1_listener* listener, void* data) {
+  return wl_proxy_add_listener((struct wl_proxy*)zxdg_output_v1,
+                               (void (**)(void))listener, data);
+}
+
+#define ZXDG_OUTPUT_V1_DESTROY 0
+
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+#define ZXDG_OUTPUT_V1_LOGICAL_POSITION_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+#define ZXDG_OUTPUT_V1_LOGICAL_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+#define ZXDG_OUTPUT_V1_DONE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+#define ZXDG_OUTPUT_V1_NAME_SINCE_VERSION 2
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+#define ZXDG_OUTPUT_V1_DESCRIPTION_SINCE_VERSION 2
+
+/**
+ * @ingroup iface_zxdg_output_v1
+ */
+#define ZXDG_OUTPUT_V1_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_output_v1 */
+static inline void zxdg_output_v1_set_user_data(
+    struct zxdg_output_v1* zxdg_output_v1, void* user_data) {
+  wl_proxy_set_user_data((struct wl_proxy*)zxdg_output_v1, user_data);
+}
+
+/** @ingroup iface_zxdg_output_v1 */
+static inline void* zxdg_output_v1_get_user_data(
+    struct zxdg_output_v1* zxdg_output_v1) {
+  return wl_proxy_get_user_data((struct wl_proxy*)zxdg_output_v1);
+}
+
+static inline uint32_t zxdg_output_v1_get_version(
+    struct zxdg_output_v1* zxdg_output_v1) {
+  return wl_proxy_get_version((struct wl_proxy*)zxdg_output_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_output_v1
+ *
+ * Using this request a client can tell the server that it is not
+ * going to use the xdg_output object anymore.
+ */
+static inline void zxdg_output_v1_destroy(
+    struct zxdg_output_v1* zxdg_output_v1) {
+  wl_proxy_marshal((struct wl_proxy*)zxdg_output_v1, ZXDG_OUTPUT_V1_DESTROY);
+
+  wl_proxy_destroy((struct wl_proxy*)zxdg_output_v1);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/widget/gtk/wayland/xdg-output-unstable-v1-protocol.c b/widget/gtk/wayland/xdg-output-unstable-v1-protocol.c
new file mode 100644
index 0000000000..f80133f357
--- /dev/null
+++ b/widget/gtk/wayland/xdg-output-unstable-v1-protocol.c
@@ -0,0 +1,74 @@
+/* Generated by wayland-scanner 1.18.0 */
+
+/*
+ * Copyright © 2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <gdk/gdkwayland.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+#  define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#  define WL_PRIVATE __attribute__((visibility("hidden")))
+#else
+#  define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface zxdg_output_v1_interface;
+
+static const struct wl_interface* xdg_output_unstable_v1_types[] = {
+    NULL,
+    NULL,
+    &zxdg_output_v1_interface,
+    &wl_output_interface,
+};
+
+static const struct wl_message zxdg_output_manager_v1_requests[] = {
+    {"destroy", "", xdg_output_unstable_v1_types + 0},
+    {"get_xdg_output", "no", xdg_output_unstable_v1_types + 2},
+};
+
+WL_PRIVATE const struct wl_interface zxdg_output_manager_v1_interface = {
+    "zxdg_output_manager_v1", 3, 2, zxdg_output_manager_v1_requests, 0, NULL,
+};
+
+static const struct wl_message zxdg_output_v1_requests[] = {
+    {"destroy", "", xdg_output_unstable_v1_types + 0},
+};
+
+static const struct wl_message zxdg_output_v1_events[] = {
+    {"logical_position", "ii", xdg_output_unstable_v1_types + 0},
+    {"logical_size", "ii", xdg_output_unstable_v1_types + 0},
+    {"done", "", xdg_output_unstable_v1_types + 0},
+    {"name", "2s", xdg_output_unstable_v1_types + 0},
+    {"description", "2s", xdg_output_unstable_v1_types + 0},
+};
+
+WL_PRIVATE const struct wl_interface zxdg_output_v1_interface = {
+    "zxdg_output_v1", 3, 1, zxdg_output_v1_requests, 5, zxdg_output_v1_events,
+};