Revert "Bug 1998657 [Wayland] Create EGLWindow over offscreen wl_surface and make it always available r=emilio" for causing valgrind failures

This reverts commit de6ac36.

Revert "Bug 1998657 [Wayland] Make WaylandSurface ready to draw right after its created r=emilio"

This reverts commit b39b0ef.

Author: Sandor Molnar

widget/gtk/MozContainerWayland.cpp

@@ -99,6 +99,11 @@ static void moz_container_wayland_invalidate(MozContainer* container) {
   gdk_window_invalidate_rect(window, nullptr, true);
 }
 
+void moz_container_wayland_add_or_fire_initial_draw_callback(
+    MozContainer* container, const std::function<void(void)>& initial_draw_cb) {
+  MOZ_WL_SURFACE(container)->AddOrFireReadyToDrawCallback(initial_draw_cb);
+}
+
 void moz_container_wayland_unmap(GtkWidget* widget) {
   g_return_if_fail(IS_MOZ_CONTAINER(widget));
 
@@ -138,9 +143,23 @@ gboolean moz_container_wayland_map_event(GtkWidget* widget,
   // 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.
+  MOZ_WL_CONTAINER(widget)->waiting_to_show = true;
+  MozContainer* container = MOZ_CONTAINER(widget);
+  MOZ_WL_SURFACE(container)->AddOrFireReadyToDrawCallback(
+      [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);
+      });
+
   // Don't create wl_subsurface in map_event when it's already created or
   // if we create it for the first time.
-  MozContainer* container = MOZ_CONTAINER(widget);
   if (MOZ_WL_SURFACE(container)->IsMapped() ||
       MOZ_WL_CONTAINER(container)->before_first_size_alloc) {
     return false;
@@ -262,7 +281,40 @@ static bool moz_container_wayland_ensure_surface(MozContainer* container,
   return true;
 }
 
+struct wl_egl_window* moz_container_wayland_get_egl_window(
+    MozContainer* container) {
+  LOGCONTAINER("%s [%p] mapped %d eglwindow %d", __FUNCTION__,
+               (void*)moz_container_get_nsWindow(container),
+               MOZ_WL_SURFACE(container)->IsMapped(),
+               MOZ_WL_SURFACE(container)->HasEGLWindow());
+
+  if (!MOZ_WL_SURFACE(container)->IsMapped()) {
+    return nullptr;
+  }
+
+  // TODO: Get size from bounds instead of GdkWindow?
+  // We may be in rendering/compositor thread here.
+  GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container));
+  DesktopIntSize size(gdk_window_get_width(window),
+                      gdk_window_get_height(window));
+  return MOZ_WL_SURFACE(container)->GetEGLWindow(size);
+}
+
+gboolean moz_container_wayland_can_draw(MozContainer* container) {
+  return MOZ_WL_SURFACE(container)->IsReadyToDraw();
+}
+
 double moz_container_wayland_get_scale(MozContainer* container) {
   nsWindow* window = moz_container_get_nsWindow(container);
   return window ? window->FractionalScaleFactor() : 1.0;
 }
+
+bool moz_container_wayland_is_waiting_to_show(MozContainer* container) {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+  return MOZ_WL_CONTAINER(container)->waiting_to_show;
+}
+
+void moz_container_wayland_clear_waiting_to_show_flag(MozContainer* container) {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+  MOZ_WL_CONTAINER(container)->waiting_to_show = false;
+}

widget/gtk/MozContainerWayland.h

@@ -43,13 +43,24 @@ struct MozContainerWayland {
 
   RefPtr<mozilla::widget::WaylandSurface> mSurface;
   gboolean before_first_size_alloc = false;
+  gboolean waiting_to_show = false;
 };
 
 void moz_container_wayland_map(GtkWidget*);
 gboolean moz_container_wayland_map_event(GtkWidget*, GdkEventAny*);
 void moz_container_wayland_size_allocate(GtkWidget*, GtkAllocation*);
 void moz_container_wayland_unmap(GtkWidget*);
+
+struct wl_egl_window* moz_container_wayland_get_egl_window(
+    MozContainer* container);
+
+void moz_container_wayland_add_or_fire_initial_draw_callback(
+    MozContainer* container, const std::function<void(void)>& initial_draw_cb);
+
 wl_surface* moz_gtk_widget_get_wl_surface(GtkWidget* aWidget);
+gboolean moz_container_wayland_can_draw(MozContainer* container);
 double moz_container_wayland_get_scale(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__ */

widget/gtk/WaylandSurface.cpp

@@ -117,6 +117,104 @@ WaylandSurface::~WaylandSurface() {
                      "We can't release WaylandSurface with numap callback!");
 }
 
+void WaylandSurface::ReadyToDrawFrameCallbackHandler(
+    struct wl_callback* callback) {
+  LOGWAYLAND(
+      "WaylandSurface::ReadyToDrawFrameCallbackHandler() "
+      "mReadyToDrawFrameCallback %p mIsReadyToDraw %d initial_draw callback "
+      "%zd\n",
+      (void*)mReadyToDrawFrameCallback, (bool)mIsReadyToDraw,
+      mReadyToDrawCallbacks.size());
+
+  // We're supposed to run on main thread only.
+  AssertIsOnMainThread();
+
+  // mReadyToDrawFrameCallback/callback can be nullptr when redering directly
+  // to GtkWidget and ReadyToDrawFrameCallbackHandler is called by us from main
+  // thread by WaylandSurface::Map().
+  MOZ_RELEASE_ASSERT(mReadyToDrawFrameCallback == callback);
+
+  std::vector<std::function<void(void)>> cbs;
+  {
+    WaylandSurfaceLock lock(this);
+    MozClearPointer(mReadyToDrawFrameCallback, wl_callback_destroy);
+    // It's possible that we're already unmapped so quit in such case.
+    if (!mIsMapped) {
+      LOGWAYLAND("  WaylandSurface is unmapped, quit.");
+      if (!mReadyToDrawCallbacks.empty()) {
+        NS_WARNING("Unmapping WaylandSurface with active draw callback!");
+        mReadyToDrawCallbacks.clear();
+      }
+      return;
+    }
+    if (mIsReadyToDraw) {
+      return;
+    }
+    mIsReadyToDraw = true;
+    cbs = std::move(mReadyToDrawCallbacks);
+
+    RequestFrameCallbackLocked(lock);
+  }
+
+  // We can't call the callbacks under lock
+#ifdef MOZ_LOGGING
+  int callbackNum = 0;
+#endif
+  for (auto const& cb : cbs) {
+    LOGWAYLAND("  initial callback fire  [%d]", callbackNum++);
+    cb();
+  }
+}
+
+static void ReadyToDrawFrameCallbackHandler(void* aWaylandSurface,
+                                            struct wl_callback* callback,
+                                            uint32_t time) {
+  auto* waylandSurface = static_cast<WaylandSurface*>(aWaylandSurface);
+  waylandSurface->ReadyToDrawFrameCallbackHandler(callback);
+}
+
+static const struct wl_callback_listener
+    sWaylandSurfaceReadyToDrawFrameListener = {
+        ::ReadyToDrawFrameCallbackHandler};
+
+void WaylandSurface::AddReadyToDrawCallbackLocked(
+    const WaylandSurfaceLock& aProofOfLock,
+    const std::function<void(void)>& aDrawCB) {
+  LOGVERBOSE("WaylandSurface::AddReadyToDrawCallbackLocked()");
+  MOZ_DIAGNOSTIC_ASSERT(&aProofOfLock == mSurfaceLock);
+  mReadyToDrawCallbacks.push_back(aDrawCB);
+}
+
+void WaylandSurface::AddOrFireReadyToDrawCallback(
+    const std::function<void(void)>& aDrawCB) {
+  {
+    WaylandSurfaceLock lock(this);
+    if (!mIsReadyToDraw) {
+      LOGVERBOSE(
+          "WaylandSurface::AddOrFireReadyToDrawCallback() callback stored");
+      mReadyToDrawCallbacks.push_back(aDrawCB);
+      return;
+    }
+  }
+
+  LOGWAYLAND("WaylandSurface::AddOrFireReadyToDrawCallback() callback fire");
+
+  // We're ready to draw and we have a surface to draw into.
+  aDrawCB();
+}
+
+void WaylandSurface::ClearReadyToDrawCallbacksLocked(
+    const WaylandSurfaceLock& aProofOfLock) {
+  MOZ_DIAGNOSTIC_ASSERT(&aProofOfLock == mSurfaceLock);
+  MozClearPointer(mReadyToDrawFrameCallback, wl_callback_destroy);
+  mReadyToDrawCallbacks.clear();
+}
+
+void WaylandSurface::ClearReadyToDrawCallbacks() {
+  WaylandSurfaceLock lock(this);
+  ClearReadyToDrawCallbacksLocked(lock);
+}
+
 bool WaylandSurface::HasEmulatedFrameCallbackLocked(
     const WaylandSurfaceLock& aProofOfLock) const {
   return mFrameCallbackHandler.IsSet() && mFrameCallbackHandler.mEmulated;
@@ -135,7 +233,7 @@ void WaylandSurface::FrameCallbackHandler(struct wl_callback* aCallback,
     WaylandSurfaceLock lock(this);
 
     // Don't run emulated callbacks on hidden surfaces
-    if ((emulatedCallback || aRoutedFromChildSurface) && !mIsVisible) {
+    if ((emulatedCallback || aRoutedFromChildSurface) && !mIsReadyToDraw) {
       return;
     }
 
@@ -161,7 +259,6 @@ void WaylandSurface::FrameCallbackHandler(struct wl_callback* aCallback,
     // We're getting regular frame callback from this surface so we must
     // have buffer attached.
     if (!emulatedCallback && !aRoutedFromChildSurface) {
-      mIsVisible = true;
       mBufferAttached = true;
     }
 
@@ -381,7 +478,8 @@ bool WaylandSurface::MapLocked(const WaylandSurfaceLock& aProofOfLock,
                                wl_surface* aParentWLSurface,
                                WaylandSurfaceLock* aParentWaylandSurfaceLock,
                                gfx::IntPoint aSubsurfacePosition,
-                               bool aSubsurfaceDesync) {
+                               bool aSubsurfaceDesync,
+                               bool aUseReadyToDrawCallback) {
   LOGWAYLAND("WaylandSurface::MapLocked()");
   MOZ_DIAGNOSTIC_ASSERT(&aProofOfLock == mSurfaceLock);
   MOZ_DIAGNOSTIC_ASSERT(!mIsMapped, "Already mapped?");
@@ -421,6 +519,14 @@ bool WaylandSurface::MapLocked(const WaylandSurfaceLock& aProofOfLock,
   LOGWAYLAND(" subsurface position [%d,%d]", (int)mSubsurfacePosition.x,
              (int)mSubsurfacePosition.y);
 
+  if (aUseReadyToDrawCallback) {
+    mReadyToDrawFrameCallback = wl_surface_frame(mParentSurface);
+    wl_callback_add_listener(mReadyToDrawFrameCallback,
+                             &sWaylandSurfaceReadyToDrawFrameListener, this);
+    LOGWAYLAND("    created ready to draw frame callback ID %d\n",
+               wl_proxy_get_id((struct wl_proxy*)mReadyToDrawFrameCallback));
+  }
+
   LOGWAYLAND("  register frame callback");
   RequestFrameCallbackLocked(aProofOfLock);
 
@@ -450,7 +556,8 @@ bool WaylandSurface::MapLocked(const WaylandSurfaceLock& aProofOfLock,
                                gfx::IntPoint aSubsurfacePosition) {
   return MapLocked(aProofOfLock, nullptr, aParentWaylandSurfaceLock,
                    aSubsurfacePosition,
-                   /* aSubsurfaceDesync */ false);
+                   /* aSubsurfaceDesync */ false,
+                   /* aUseReadyToDrawCallback */ false);
 }
 
 void WaylandSurface::SetUnmapCallbackLocked(
@@ -502,11 +609,11 @@ void WaylandSurface::UnmapLocked(WaylandSurfaceLock& aSurfaceLock) {
     return;
   }
   mIsMapped = false;
-  mIsVisible = false;
 
   LOGWAYLAND("WaylandSurface::UnmapLocked()");
 
   RemoveAttachedBufferLocked(aSurfaceLock);
+  ClearReadyToDrawCallbacksLocked(aSurfaceLock);
   ClearFrameCallbackLocked(aSurfaceLock);
   ClearScaleLocked(aSurfaceLock);
 
@@ -526,6 +633,9 @@ void WaylandSurface::UnmapLocked(WaylandSurfaceLock& aSurfaceLock) {
   MozClearPointer(mPendingOpaqueRegion, wl_region_destroy);
   MozClearPointer(mOpaqueRegionFrameCallback, wl_callback_destroy);
 
+  mIsReadyToDraw = false;
+  mBufferAttached = false;
+
   // Remove references to WaylandBuffers attached to mSurface,
   // we don't want to get any buffer release callback when we're unmapped.
   ReleaseAllWaylandTransactionsLocked(aSurfaceLock);

widget/gtk/WaylandSurface.h

@@ -43,6 +43,10 @@ class WaylandSurface final {
   void SetLoggingWidget(void* aWidget) { mLoggingWidget = aWidget; }
 #endif
 
+  void ReadyToDrawFrameCallbackHandler(struct wl_callback* aCallback);
+  void AddOrFireReadyToDrawCallback(const std::function<void(void)>& aDrawCB);
+  void ClearReadyToDrawCallbacks();
+
   void FrameCallbackHandler(struct wl_callback* aCallback, uint32_t aTime,
                             bool aRoutedFromChildSurface);
 
@@ -74,12 +78,11 @@ class WaylandSurface final {
   bool SetEGLWindowSize(LayoutDeviceIntSize aSize);
   bool HasEGLWindow() const { return !!mEGLWindow; }
 
+  // Read to draw means we got frame callback from parent surface
+  // where we attached to.
+  bool IsReadyToDraw() const { return mIsReadyToDraw; }
   // Mapped means we have all internals created.
   bool IsMapped() const { return mIsMapped; }
-
-  // We've got first frame callback so we're really visible now.
-  bool IsVisible() const { return mIsVisible; }
-
   // Indicate that Wayland surface uses Gdk resources which
   // need to be released on main thread by GdkCleanUpLocked().
   // It may be called after Unmap() to make sure
@@ -119,6 +122,10 @@ class WaylandSurface final {
   bool CreateViewportLocked(const WaylandSurfaceLock& aProofOfLock,
                             bool aFollowsSizeChanges);
 
+  void AddReadyToDrawCallbackLocked(
+      const WaylandSurfaceLock& aProofOfLock,
+      const std::function<void(void)>& aInitialDrawCB);
+
   // Attach WaylandBuffer which shows WaylandBuffer content
   // on screen.
   bool AttachLocked(const WaylandSurfaceLock& aSurfaceLock,
@@ -274,7 +281,8 @@ class WaylandSurface final {
   bool MapLocked(const WaylandSurfaceLock& aProofOfLock,
                  wl_surface* aParentWLSurface,
                  WaylandSurfaceLock* aParentWaylandSurfaceLock,
-                 gfx::IntPoint aSubsurfacePosition, bool aSubsurfaceDesync);
+                 gfx::IntPoint aSubsurfacePosition, bool aSubsurfaceDesync,
+                 bool aUseReadyToDrawCallback = true);
 
   void SetSizeLocked(const WaylandSurfaceLock& aProofOfLock,
                      gfx::IntSize aSizeScaled, gfx::IntSize aUnscaledSize);
@@ -296,18 +304,21 @@ class WaylandSurface final {
   bool HasEmulatedFrameCallbackLocked(
       const WaylandSurfaceLock& aProofOfLock) const;
 
+  void ClearReadyToDrawCallbacksLocked(const WaylandSurfaceLock& aProofOfLock);
+
   void ClearScaleLocked(const WaylandSurfaceLock& aProofOfLock);
 
   // Weak ref to owning widget (nsWindow or NativeLayerWayland),
   // used for diagnostics/logging only.
   void* mLoggingWidget = nullptr;
 
-  // mIsMapped means we're supposed to be visible
-  // (or not if Wayland compositor decides so).
+  // WaylandSurface mapped - we have valid wl_surface where we can paint to.
   mozilla::Atomic<bool, mozilla::Relaxed> mIsMapped{false};
 
-  // mIsVisible means we're really visible as we've got frame callback.
-  mozilla::Atomic<bool, mozilla::Relaxed> mIsVisible{false};
+  // Wayland shows only subsurfaces of visible parent surfaces.
+  // mIsReadyToDraw means our parent wl_surface has content so
+  // this WaylandSurface can be visible on screen and get get frame callback.
+  mozilla::Atomic<bool, mozilla::Relaxed> mIsReadyToDraw{false};
 
   // We used Gdk functions which needs clean up in main thread.
   mozilla::Atomic<bool, mozilla::Relaxed> mIsPendingGdkCleanup{false};
@@ -374,6 +385,11 @@ class WaylandSurface final {
   bool mBufferTransformFlippedX = false;
   bool mBufferTransformFlippedY = false;
 
+  // Frame callback registered to parent surface. When we get it we know
+  // parent surface is ready and we can paint.
+  wl_callback* mReadyToDrawFrameCallback = nullptr;
+  std::vector<std::function<void(void)>> mReadyToDrawCallbacks;
+
   // Frame callbacks of this surface
   wl_callback* mFrameCallback = nullptr;