--- a/gfx/gl/GLContextProviderGLX.cpp
+++ b/gfx/gl/GLContextProviderGLX.cpp
@@ -12,17 +12,17 @@
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include "X11UndefineNone.h"
 
 #include "mozilla/MathAlgorithms.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/layers/CompositorOptions.h"
 #include "mozilla/widget/CompositorWidget.h"
-#include "mozilla/widget/X11CompositorWidget.h"
+#include "mozilla/widget/GtkCompositorWidget.h"
 #include "mozilla/Unused.h"
 
 #include "prenv.h"
 #include "GLContextProvider.h"
 #include "GLLibraryLoader.h"
 #include "nsDebug.h"
 #include "nsIWidget.h"
 #include "GLXLibrary.h"
@@ -798,17 +798,17 @@ CreateForWidget(Display* aXDisplay, Wind
     }
     return GLContextGLX::CreateGLContext(flags, SurfaceCaps::Any(), false, aXDisplay,
                                          aXWindow, config, false, nullptr);
 }
 
 already_AddRefed<GLContext>
 GLContextProviderGLX::CreateForCompositorWidget(CompositorWidget* aCompositorWidget, bool aForceAccelerated)
 {
-    X11CompositorWidget* compWidget = aCompositorWidget->AsX11();
+    GtkCompositorWidget* compWidget = aCompositorWidget->AsX11();
     MOZ_ASSERT(compWidget);
 
     return CreateForWidget(compWidget->XDisplay(),
                            compWidget->XWindow(),
                            compWidget->GetCompositorOptions().UseWebRender(),
                            aForceAccelerated);
 }
 

--- a/widget/CompositorWidget.h
+++ b/widget/CompositorWidget.h
@@ -28,17 +28,17 @@ class Compositor;
 } // namespace layers
 namespace gfx {
 class DrawTarget;
 class SourceSurface;
 } // namespace gfx
 namespace widget {
 
 class WinCompositorWidget;
-class X11CompositorWidget;
+class GtkCompositorWidget;
 class AndroidCompositorWidget;
 class CompositorWidgetInitData;
 
 // Gecko widgets usually need to communicate with the CompositorWidget with
 // platform-specific messages (for example to update the window size or
 // transparency). This functionality is controlled through a "host". Since
 // this functionality is platform-dependent, it is only forward declared
 // here.
@@ -282,17 +282,17 @@ public:
   /**
    * This is only used by out-of-process compositors.
    */
   virtual RefPtr<VsyncObserver> GetVsyncObserver() const;
 
   virtual WinCompositorWidget* AsWindows() {
     return nullptr;
   }
-  virtual X11CompositorWidget* AsX11() {
+  virtual GtkCompositorWidget* AsX11() {
     return nullptr;
   }
   virtual AndroidCompositorWidget* AsAndroid() {
     return nullptr;
   }
 
   /**
    * Return the platform-specific delegate for the widget, if any.

--- a/widget/gtk/CompositorWidgetChild.h
+++ b/widget/gtk/CompositorWidgetChild.h
@@ -1,17 +1,17 @@
 /* -*- 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 "X11CompositorWidget.h"
+#include "GtkCompositorWidget.h"
 #include "mozilla/widget/PCompositorWidgetChild.h"
 #include "mozilla/widget/CompositorWidgetVsyncObserver.h"
 
 namespace mozilla {
 namespace widget {
 
 class CompositorWidgetChild final
  : public PCompositorWidgetChild

--- a/widget/gtk/CompositorWidgetParent.cpp
+++ b/widget/gtk/CompositorWidgetParent.cpp
@@ -7,17 +7,17 @@
 #include "mozilla/Unused.h"
 #include "mozilla/widget/PlatformWidgetTypes.h"
 
 namespace mozilla {
 namespace widget {
 
 CompositorWidgetParent::CompositorWidgetParent(const CompositorWidgetInitData& aInitData,
                                                const layers::CompositorOptions& aOptions)
- : X11CompositorWidget(aInitData.get_X11CompositorWidgetInitData(), aOptions)
+ : GtkCompositorWidget(aInitData.get_GtkCompositorWidgetInitData(), aOptions)
 {
   MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_GPU);
 }
 
 CompositorWidgetParent::~CompositorWidgetParent()
 {
 }
 

--- a/widget/gtk/CompositorWidgetParent.h
+++ b/widget/gtk/CompositorWidgetParent.h
@@ -1,25 +1,25 @@
 /* -*- 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 "X11CompositorWidget.h"
+#include "GtkCompositorWidget.h"
 #include "mozilla/widget/PCompositorWidgetParent.h"
 
 namespace mozilla {
 namespace widget {
 
 class CompositorWidgetParent final
  : public PCompositorWidgetParent,
-   public X11CompositorWidget
+   public GtkCompositorWidget
 {
 public:
   explicit CompositorWidgetParent(const CompositorWidgetInitData& aInitData,
                                   const layers::CompositorOptions& aOptions);
   ~CompositorWidgetParent() override;
 
   void ActorDestroy(ActorDestroyReason aWhy) override { }
 

rename from widget/gtk/X11CompositorWidget.cpp
rename to widget/gtk/GtkCompositorWidget.cpp
--- a/widget/gtk/X11CompositorWidget.cpp
+++ b/widget/gtk/GtkCompositorWidget.cpp
@@ -1,110 +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/. */
 
-#include "X11CompositorWidget.h"
+#include "GtkCompositorWidget.h"
 
 #include "gfxPlatformGtk.h"
 #include "mozilla/layers/CompositorThread.h"
 #include "mozilla/widget/InProcessCompositorWidget.h"
 #include "mozilla/widget/PlatformWidgetTypes.h"
 #include "nsWindow.h"
 
 namespace mozilla {
 namespace widget {
 
-X11CompositorWidget::X11CompositorWidget(const X11CompositorWidgetInitData& aInitData,
-                                         const CompositorOptions& aOptions,
+GtkCompositorWidget::GtkCompositorWidget(const GtkCompositorWidgetInitData& aInitData,
+                                         const layers::CompositorOptions& aOptions,
                                          nsWindow* aWindow)
       : CompositorWidget(aOptions)
       , mWidget(aWindow)
 {
   // If we have a nsWindow, then grab the already existing display connection
   // If we don't, then use the init data to connect to the display
   if (aWindow) {
     mXDisplay = aWindow->XDisplay();
   } else {
     mXDisplay = XOpenDisplay(aInitData.XDisplayString().get());
   }
-  mXWindow = (Window)aInitData.XWindow();
 
-  // Grab the window's visual and depth
-  XWindowAttributes windowAttrs;
-  XGetWindowAttributes(mXDisplay, mXWindow, &windowAttrs);
-
-  Visual*   visual = windowAttrs.visual;
-  int       depth = windowAttrs.depth;
+#ifdef MOZ_WAYLAND
+  if (!mXDisplay) {
+    MOZ_RELEASE_ASSERT(aWindow,
+      "We're running on Wayland and but without valid nsWindow.");
+    mProvider.Initialize(aWindow);
+  } else
+#endif
+  {
+    mXWindow = (Window)aInitData.XWindow();
 
-  // Initialize the window surface provider
-  mProvider.Initialize(
-    mXDisplay,
-    mXWindow,
-    visual,
-    depth
-    );
+    // Grab the window's visual and depth
+    XWindowAttributes windowAttrs;
+    XGetWindowAttributes(mXDisplay, mXWindow, &windowAttrs);
+
+    Visual*   visual = windowAttrs.visual;
+    int       depth = windowAttrs.depth;
 
+    // Initialize the window surface provider
+    mProvider.Initialize(
+      mXDisplay,
+      mXWindow,
+      visual,
+      depth
+      );
+  }
   mClientSize = aInitData.InitialClientSize();
 }
 
-X11CompositorWidget::~X11CompositorWidget()
+GtkCompositorWidget::~GtkCompositorWidget()
 {
   mProvider.CleanupResources();
 
   // If we created our own display connection, we need to destroy it
   if (!mWidget && mXDisplay) {
     XCloseDisplay(mXDisplay);
     mXDisplay = nullptr;
   }
 }
 
 already_AddRefed<gfx::DrawTarget>
-X11CompositorWidget::StartRemoteDrawing()
+GtkCompositorWidget::StartRemoteDrawing()
 {
   return nullptr;
 }
 void
-X11CompositorWidget::EndRemoteDrawing()
+GtkCompositorWidget::EndRemoteDrawing()
 {
 }
 
 already_AddRefed<gfx::DrawTarget>
-X11CompositorWidget::StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
+GtkCompositorWidget::StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
                                                 layers::BufferMode* aBufferMode)
 {
   return mProvider.StartRemoteDrawingInRegion(aInvalidRegion,
                                               aBufferMode);
 }
 
-void X11CompositorWidget::EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
+void GtkCompositorWidget::EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
                               LayoutDeviceIntRegion& aInvalidRegion)
 {
   mProvider.EndRemoteDrawingInRegion(aDrawTarget,
                                      aInvalidRegion);
 }
 
-nsIWidget* X11CompositorWidget::RealWidget()
+nsIWidget* GtkCompositorWidget::RealWidget()
 {
   return mWidget;
 }
 
 void
-X11CompositorWidget::NotifyClientSizeChanged(const LayoutDeviceIntSize& aClientSize)
+GtkCompositorWidget::NotifyClientSizeChanged(const LayoutDeviceIntSize& aClientSize)
 {
   mClientSize = aClientSize;
 }
 
 LayoutDeviceIntSize
-X11CompositorWidget::GetClientSize()
+GtkCompositorWidget::GetClientSize()
 {
   return mClientSize;
 }
 
 uintptr_t
-X11CompositorWidget::GetWidgetKey()
+GtkCompositorWidget::GetWidgetKey()
 {
   return reinterpret_cast<uintptr_t>(mWidget);
 }
 
 } // namespace widget
 } // namespace mozilla

rename from widget/gtk/X11CompositorWidget.h
rename to widget/gtk/GtkCompositorWidget.h
--- a/widget/gtk/X11CompositorWidget.h
+++ b/widget/gtk/GtkCompositorWidget.h
@@ -1,15 +1,15 @@
 /* -*- 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_X11CompositorWidget_h
-#define widget_gtk_X11CompositorWidget_h
+#ifndef widget_gtk_GtkCompositorWidget_h
+#define widget_gtk_GtkCompositorWidget_h
 
 #include "mozilla/widget/CompositorWidget.h"
 #include "WindowSurfaceProvider.h"
 
 class nsIWidget;
 class nsWindow;
 
 namespace mozilla {
@@ -23,44 +23,44 @@ public:
 
   // CompositorWidgetDelegate Overrides
 
   PlatformCompositorWidgetDelegate* AsPlatformSpecificDelegate() override {
     return this;
   }
 };
 
-class X11CompositorWidgetInitData;
+class GtkCompositorWidgetInitData;
 
-class X11CompositorWidget
+class GtkCompositorWidget
  : public CompositorWidget
  , public PlatformCompositorWidgetDelegate
 {
 public:
-  X11CompositorWidget(const X11CompositorWidgetInitData& aInitData,
+  GtkCompositorWidget(const GtkCompositorWidgetInitData& aInitData,
                       const layers::CompositorOptions& aOptions,
                       nsWindow* aWindow = nullptr);
-  ~X11CompositorWidget();
+  ~GtkCompositorWidget();
 
   // CompositorWidget Overrides
 
   already_AddRefed<gfx::DrawTarget> StartRemoteDrawing() override;
   void EndRemoteDrawing() override;
 
   already_AddRefed<gfx::DrawTarget>
   StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
                              layers::BufferMode* aBufferMode) override;
   void EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
                                 LayoutDeviceIntRegion& aInvalidRegion) override;
   uintptr_t GetWidgetKey() override;
 
   LayoutDeviceIntSize GetClientSize() override;
 
   nsIWidget* RealWidget() override;
-  X11CompositorWidget* AsX11() override { return this; }
+  GtkCompositorWidget* AsX11() override { return this; }
   CompositorWidgetDelegate* AsDelegate() override { return this; }
 
   Display* XDisplay() const { return mXDisplay; }
   Window XWindow() const { return mXWindow; }
 
   // PlatformCompositorWidgetDelegate Overrides
 
   void NotifyClientSizeChanged(const LayoutDeviceIntSize& aClientSize) override;
@@ -74,9 +74,9 @@ private:
   Display* mXDisplay;
   Window   mXWindow;
   WindowSurfaceProvider mProvider;
 };
 
 } // namespace widget
 } // namespace mozilla
 
-#endif // widget_gtk_X11CompositorWidget_h
+#endif // widget_gtk_GtkCompositorWidget_h

rename from widget/gtk/InProcessX11CompositorWidget.cpp
rename to widget/gtk/InProcessGtkCompositorWidget.cpp
--- a/widget/gtk/InProcessX11CompositorWidget.cpp
+++ b/widget/gtk/InProcessGtkCompositorWidget.cpp
@@ -2,45 +2,45 @@
 /* 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 "InProcessX11CompositorWidget.h"
+#include "InProcessGtkCompositorWidget.h"
 #include "nsWindow.h"
 
 namespace mozilla {
 namespace 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 InProcessX11CompositorWidget(aInitData.get_X11CompositorWidgetInitData(),
+    return new InProcessGtkCompositorWidget(aInitData.get_GtkCompositorWidgetInitData(),
                                             aOptions, static_cast<nsWindow*>(aWidget));
   }
 }
 
-InProcessX11CompositorWidget::InProcessX11CompositorWidget(const X11CompositorWidgetInitData& aInitData,
+InProcessGtkCompositorWidget::InProcessGtkCompositorWidget(const GtkCompositorWidgetInitData& aInitData,
                                                            const layers::CompositorOptions& aOptions,
                                                            nsWindow* aWindow)
-  : X11CompositorWidget(aInitData, aOptions, aWindow)
+  : GtkCompositorWidget(aInitData, aOptions, aWindow)
 {
 }
 
 void
-InProcessX11CompositorWidget::ObserveVsync(VsyncObserver* aObserver)
+InProcessGtkCompositorWidget::ObserveVsync(VsyncObserver* aObserver)
 {
   if (RefPtr<CompositorVsyncDispatcher> cvd = mWidget->GetCompositorVsyncDispatcher()) {
     cvd->SetCompositorVsyncObserver(aObserver);
   }
 }
 
 } // namespace widget
 } // namespace mozilla

rename from widget/gtk/InProcessX11CompositorWidget.h
rename to widget/gtk/InProcessGtkCompositorWidget.h
--- a/widget/gtk/InProcessX11CompositorWidget.h
+++ b/widget/gtk/InProcessGtkCompositorWidget.h
@@ -1,31 +1,31 @@
 /* -*- 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_InProcessX11CompositorWidgetParent_h
-#define widget_gtk_InProcessX11CompositorWidgetParent_h
+#ifndef widget_gtk_InProcessGtkCompositorWidgetParent_h
+#define widget_gtk_InProcessGtkCompositorWidgetParent_h
 
-#include "X11CompositorWidget.h"
+#include "GtkCompositorWidget.h"
 
 class nsWindow;
 
 namespace mozilla {
 namespace widget {
 
-class InProcessX11CompositorWidget final : public X11CompositorWidget
+class InProcessGtkCompositorWidget final : public GtkCompositorWidget
 {
 public:
-  InProcessX11CompositorWidget(const X11CompositorWidgetInitData& aInitData,
+  InProcessGtkCompositorWidget(const GtkCompositorWidgetInitData& aInitData,
                                const layers::CompositorOptions& aOptions,
                                nsWindow* aWindow);
 
   // CompositorWidgetDelegate
 
   void ObserveVsync(VsyncObserver* aObserver) override;
 };
 
 } // namespace widget
 } // namespace mozilla
 
-#endif // widget_gtk_InProcessX11CompositorWidgetParent_h
+#endif // widget_gtk_InProcessGtkCompositorWidgetParent_h

--- a/widget/gtk/PlatformWidgetTypes.ipdlh
+++ b/widget/gtk/PlatformWidgetTypes.ipdlh
@@ -6,24 +6,24 @@
 
 include HeadlessWidgetTypes;
 
 using mozilla::LayoutDeviceIntSize from "Units.h";
 
 namespace mozilla {
 namespace widget {
 
-struct X11CompositorWidgetInitData
+struct GtkCompositorWidgetInitData
 {
   uintptr_t           XWindow;
   nsCString           XDisplayString;
 
   LayoutDeviceIntSize InitialClientSize;
 };
 
 union CompositorWidgetInitData
 {
-  X11CompositorWidgetInitData;
+  GtkCompositorWidgetInitData;
   HeadlessCompositorWidgetInitData;
 };
 
 } // namespace widget
 } // namespace mozilla

--- a/widget/gtk/WindowSurfaceProvider.cpp
+++ b/widget/gtk/WindowSurfaceProvider.cpp
@@ -6,29 +6,36 @@
 
 #include "WindowSurfaceProvider.h"
 
 #include "gfxPlatformGtk.h"
 #include "mozilla/layers/LayersTypes.h"
 #include "WindowSurfaceX11Image.h"
 #include "WindowSurfaceX11SHM.h"
 #include "WindowSurfaceXRender.h"
+#ifdef MOZ_WAYLAND
+#include "WindowSurfaceWayland.h"
+#endif
 
 namespace mozilla {
 namespace widget {
 
 using namespace mozilla::gfx;
 using namespace mozilla::layers;
 
 WindowSurfaceProvider::WindowSurfaceProvider()
-    : mXDisplay(nullptr)
+    : mIsX11Display(false)
+    , mXDisplay(nullptr)
     , mXWindow(0)
     , mXVisual(nullptr)
     , mXDepth(0)
     , mWindowSurface(nullptr)
+#ifdef MOZ_WAYLAND
+    , mWidget(nullptr)
+#endif
 {
 }
 
 void WindowSurfaceProvider::Initialize(
       Display* aDisplay,
       Window aWindow,
       Visual* aVisual,
       int aDepth)
@@ -38,25 +45,45 @@ void WindowSurfaceProvider::Initialize(
 
   // This should also be a valid initialization
   MOZ_ASSERT(aDisplay && aWindow != X11None && aVisual);
 
   mXDisplay = aDisplay;
   mXWindow = aWindow;
   mXVisual = aVisual;
   mXDepth = aDepth;
+  mIsX11Display = true;
 }
+
+#ifdef MOZ_WAYLAND
+void WindowSurfaceProvider::Initialize(nsWindow *aWidget)
+{
+  MOZ_ASSERT(!aWidget->IsX11Display(),
+             "We are supposed to have a Wayland display!");
+
+  mWidget = aWidget;
+  mIsX11Display = false;
+}
+#endif
+
 void WindowSurfaceProvider::CleanupResources()
 {
   mWindowSurface = nullptr;
 }
 
 UniquePtr<WindowSurface>
 WindowSurfaceProvider::CreateWindowSurface()
 {
+#ifdef MOZ_WAYLAND
+  if (!mIsX11Display) {
+    LOGDRAW(("Drawing to nsWindow %p using wl_surface\n", (void*)this));
+    return MakeUnique<WindowSurfaceWayland>(mWidget);
+  }
+#endif
+
   // We should be initialized
   MOZ_ASSERT(mXDisplay);
 
   // Blit to the window with the following priority:
   // 1. XRender (iff XRender is enabled && we are in-process)
   // 2. MIT-SHM
   // 3. XPutImage
 
@@ -89,17 +116,19 @@ WindowSurfaceProvider::StartRemoteDrawin
     mWindowSurface = CreateWindowSurface();
     if (!mWindowSurface)
       return nullptr;
   }
 
   *aBufferMode = BufferMode::BUFFER_NONE;
   RefPtr<DrawTarget> dt = nullptr;
   if (!(dt = mWindowSurface->Lock(aInvalidRegion)) &&
-      !mWindowSurface->IsFallback()) {
+      mIsX11Display && !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 = MakeUnique<WindowSurfaceX11Image>(mXDisplay, mXWindow, mXVisual, mXDepth);
     dt = mWindowSurface->Lock(aInvalidRegion);
   }
   return dt.forget();
 }
 
 void

--- a/widget/gtk/WindowSurfaceProvider.h
+++ b/widget/gtk/WindowSurfaceProvider.h
@@ -7,25 +7,31 @@
 #ifndef _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_PROVIDER_H
 #define _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_PROVIDER_H
 
 #include "mozilla/widget/WindowSurface.h"
 #include "mozilla/gfx/Types.h"
 #include "mozilla/gfx/2D.h"
 #include "Units.h"
 
+#include <gdk/gdk.h>
+#ifdef MOZ_WAYLAND
+#include <gdk/gdkwayland.h>
+#endif
 #include <X11/Xlib.h> // for Window, Display, Visual, etc.
 
+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 X11CompositorWidget, for when OMTC is enabled or disabled.
+ * nsWindow and GtkCompositorWidget, for when OMTC is enabled or disabled.
  */
 class WindowSurfaceProvider final
 {
 public:
   WindowSurfaceProvider();
 
   /**
    * Initializes the WindowSurfaceProvider by giving it the window
@@ -34,36 +40,44 @@ public:
    * while WindowSurfaceProvider is used.
    */
   void Initialize(
       Display* aDisplay,
       Window aWindow,
       Visual* aVisual,
       int aDepth);
 
+#ifdef MOZ_WAYLAND
+   void Initialize(nsWindow *aWidget);
+#endif
+
   /**
    * Releases any surfaces created by this provider.
-   * This is used by X11CompositorWidget to get rid
+   * This is used by GtkCompositorWidget to get rid
    * of resources before we close the display connection.
    */
   void CleanupResources();
 
   already_AddRefed<gfx::DrawTarget>
   StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
                              layers::BufferMode* aBufferMode);
   void EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
                                 LayoutDeviceIntRegion& aInvalidRegion);
 
 private:
   UniquePtr<WindowSurface> CreateWindowSurface();
 
-  Display*  mXDisplay;
-  Window    mXWindow;
-  Visual*   mXVisual;
-  int       mXDepth;
-
+  // Can we access X?
+  bool        mIsX11Display;
+  Display*    mXDisplay;
+  Window      mXWindow;
+  Visual*     mXVisual;
+  int         mXDepth;
   UniquePtr<WindowSurface> mWindowSurface;
+#ifdef MOZ_WAYLAND
+  nsWindow*   mWidget;
+#endif
 };
 
 }  // namespace widget
 }  // namespace mozilla
 
 #endif // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_PROVIDER_H

--- a/widget/gtk/moz.build
+++ b/widget/gtk/moz.build
@@ -50,25 +50,25 @@ UNIFIED_SOURCES += [
 SOURCES += [
     'nsWindow.cpp', # conflicts with X11 headers
 ]
 
 if CONFIG['MOZ_X11']:
     UNIFIED_SOURCES += [
         'CompositorWidgetChild.cpp',
         'CompositorWidgetParent.cpp',
-        'InProcessX11CompositorWidget.cpp',
+        'GtkCompositorWidget.cpp',
+        'InProcessGtkCompositorWidget.cpp',
         'nsIdleServiceGTK.cpp',
-        'X11CompositorWidget.cpp',
     ]
     EXPORTS.mozilla.widget += [
         'CompositorWidgetChild.h',
         'CompositorWidgetParent.h',
-        'InProcessX11CompositorWidget.h',
-        'X11CompositorWidget.h',
+        'GtkCompositorWidget.h',
+        'InProcessGtkCompositorWidget.h',
     ]
 
 if CONFIG['NS_PRINTING']:
     UNIFIED_SOURCES += [
         'nsCUPSShim.cpp',
         'nsDeviceContextSpecG.cpp',
         'nsPrintDialogGTK.cpp',
         'nsPrintOptionsGTK.cpp',

--- a/widget/gtk/nsWindow.cpp
+++ b/widget/gtk/nsWindow.cpp
@@ -117,17 +117,17 @@ using namespace mozilla::widget;
 #include "GLContextProvider.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/gfx/HelpersCairo.h"
 #include "mozilla/gfx/GPUProcessManager.h"
 #include "mozilla/layers/CompositorBridgeParent.h"
 #include "mozilla/layers/CompositorThread.h"
 
 #ifdef MOZ_X11
-#include "X11CompositorWidget.h"
+#include "GtkCompositorWidget.h"
 #include "gfxXlibSurface.h"
 #include "WindowSurfaceX11Image.h"
 #include "WindowSurfaceX11SHM.h"
 #include "WindowSurfaceXRender.h"
 #endif // MOZ_X11
 
 #include "nsShmImage.h"
 
@@ -2460,17 +2460,17 @@ nsWindow::OnSizeAllocate(GtkAllocation *
             LayoutDeviceIntRect(0, mBounds.height,
                                 size.width, size.height - mBounds.height));
         gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
     }
 
     mBounds.SizeTo(size);
 
 #ifdef MOZ_X11
-    // Notify the X11CompositorWidget of a ClientSizeChange
+    // Notify the GtkCompositorWidget of a ClientSizeChange
     if (mCompositorWidgetDelegate) {
       mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize());
     }
 #endif
 
     // 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.
@@ -4057,18 +4057,22 @@ nsWindow::Create(nsIWidget* aParent,
       mXWindow = gdk_x11_window_get_xid(mGdkWindow);
 
       GdkVisual* gdkVisual = gdk_window_get_visual(mGdkWindow);
       mXVisual = gdk_x11_visual_get_xvisual(gdkVisual);
       mXDepth = gdk_visual_get_depth(gdkVisual);
 
       mSurfaceProvider.Initialize(mXDisplay, mXWindow, mXVisual, mXDepth);
     }
+#ifdef MOZ_WAYLAND
+    else if (!mIsX11Display) {
+      mSurfaceProvider.Initialize(this);
+    }
 #endif
-
+#endif
     return NS_OK;
 }
 
 void
 nsWindow::SetWindowClass(const nsAString &xulWinType)
 {
   if (!mShell)
     return;
@@ -4158,17 +4162,17 @@ nsWindow::NativeResize()
         allocation.height = size.height;
         gtk_widget_size_allocate(widget, &allocation);
     }
     else if (mGdkWindow) {
         gdk_window_resize(mGdkWindow, size.width, size.height);
     }
 
 #ifdef MOZ_X11
-    // Notify the X11CompositorWidget of a ClientSizeChange
+    // Notify the GtkCompositorWidget of a ClientSizeChange
     // This is different than OnSizeAllocate to catch initial sizing
     if (mCompositorWidgetDelegate) {
       mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize());
     }
 #endif
 
     // Does it need to be shown because bounds were previously insane?
     if (mNeedsShow && mIsShown) {
@@ -4214,17 +4218,17 @@ nsWindow::NativeMoveResize()
         gtk_widget_size_allocate(GTK_WIDGET(mContainer), &allocation);
     }
     else if (mGdkWindow) {
         gdk_window_move_resize(mGdkWindow,
                                topLeft.x, topLeft.y, size.width, size.height);
     }
 
 #ifdef MOZ_X11
-    // Notify the X11CompositorWidget of a ClientSizeChange
+    // Notify the GtkCompositorWidget of a ClientSizeChange
     // This is different than OnSizeAllocate to catch initial sizing
     if (mCompositorWidgetDelegate) {
       mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize());
     }
 #endif
 
     // Does it need to be shown because bounds were previously insane?
     if (mNeedsShow && mIsShown) {
@@ -7039,22 +7043,32 @@ nsWindow::GetCSDSupportLevel() {
 int32_t
 nsWindow::RoundsWidgetCoordinatesTo()
 {
     return GdkScaleFactor();
 }
 
 void nsWindow::GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData)
 {
-  #ifdef MOZ_X11
-  *aInitData = mozilla::widget::X11CompositorWidgetInitData(
+#ifdef MOZ_X11
+#ifdef MOZ_WAYLAND
+  if (!mIsX11Display) {
+    *aInitData = mozilla::widget::GtkCompositorWidgetInitData(
+                                  (uintptr_t)nullptr,
+                                  nsCString(nullptr),
+                                  GetClientSize());
+  } else
+#endif
+  {
+    *aInitData = mozilla::widget::GtkCompositorWidgetInitData(
                                   mXWindow,
                                   nsCString(XDisplayString(mXDisplay)),
                                   GetClientSize());
-  #endif
+  }
+#endif
 }
 
 bool
 nsWindow::IsComposited() const
 {
   if (!mGdkWindow) {
     NS_WARNING("nsWindow::HasARGBVisual called before realization!");
     return false;