Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 553 insertions, 0 deletions

diff --git a/widget/gtk/ScreenHelperGTK.cpp b/widget/gtk/ScreenHelperGTK.cpp
new file mode 100644
index 0000000000..a4bd69f33b
--- /dev/null
+++ b/widget/gtk/ScreenHelperGTK.cpp
@@ -0,0 +1,553 @@
+/* -*- 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;
+  int transform = 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;
+  monitor->transform = transform;
+}
+
+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);
+  }
+
+  bool defaultIsLandscape;
+  if (monitor->transform == WL_OUTPUT_TRANSFORM_90 ||
+      monitor->transform == WL_OUTPUT_TRANSFORM_270) {
+    defaultIsLandscape = rect.width < rect.height;
+  } else {
+    defaultIsLandscape = rect.width >= rect.height;
+  }
+
+  hal::ScreenOrientation orientation;
+  Screen::OrientationAngle angle;
+  // transform is counter-clockwise, but Screen Orientation API is clockwise.
+  switch (monitor->transform) {
+    case WL_OUTPUT_TRANSFORM_NORMAL:
+      orientation = defaultIsLandscape
+                        ? hal::ScreenOrientation::LandscapePrimary
+                        : hal::ScreenOrientation::PortraitPrimary;
+      angle = 0;
+      break;
+    case WL_OUTPUT_TRANSFORM_90:
+      orientation = defaultIsLandscape
+                        ? hal::ScreenOrientation::PortraitPrimary
+                        : hal::ScreenOrientation::LandscapeSecondary;
+      angle = 270;
+      break;
+    case WL_OUTPUT_TRANSFORM_180:
+      orientation = defaultIsLandscape
+                        ? hal::ScreenOrientation::LandscapeSecondary
+                        : hal::ScreenOrientation::PortraitSecondary;
+      angle = 180;
+      break;
+    case WL_OUTPUT_TRANSFORM_270:
+      orientation = defaultIsLandscape
+                        ? hal::ScreenOrientation::PortraitSecondary
+                        : hal::ScreenOrientation::LandscapePrimary;
+      angle = 90;
+      break;
+    default:
+      // WL_OUTPUT_TRANSFORM_FLIPPED_* is ignore since this is unused on normal
+      // situation.
+      orientation = hal::ScreenOrientation::None;
+      angle = 0;
+      break;
+  }
+
+  LOG_SCREEN(
+      "Monitor %d [%d %d -> %d x %d depth %d content scale %f css scale %f "
+      "DPI %f, refresh %d, orientation %u, angle %u]",
+      aMonitor, rect.x, rect.y, rect.width, rect.height, pixelDepth,
+      contentsScale.scale, defaultCssScale.scale, dpi, monitor->refresh,
+      static_cast<uint32_t>(orientation), angle);
+
+  // 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, orientation, angle);
+}
+
+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<widget::Screen> 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<widget::Screen> 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