gsk: Maintain clip info for glyph nodes

We can determine once whether we are contained, instead of doing it again for every glyph. The performance impact of this is hard to measure.
gsk: Don't add images needlessly
2024-02-25 18:26:00 -05:00 · 2024-02-25 18:25:42 -05:00 · 2024-02-25 13:47:32 -05:00 · 2024-02-25 09:35:56 -05:00 · 2024-02-25 09:35:56 -05:00 · 2024-02-25 09:35:56 -05:00
298 changed files with 12938 additions and 27116 deletions
@@ -219,13 +219,11 @@ macos:
    - if: $RUNNER == "macosintel"
      variables:
        SDKROOT: /opt/sdks/MacOSX10.13.4.sdk
-        NINJA_PKG: $CI_API_V4_URL/projects/30745/packages/generic/ninja_macos/v1.11.1.1+9/ninja-1.11.1.1-cp38-cp38-macosx_11_0_x86_64.whl
      when: manual
      allow_failure: true
    - if: $RUNNER == "macosarm"
      variables:
        SDKROOT: /opt/sdks/MacOSX11.3.sdk
-        NINJA_PKG: ninja==1.11.1.1
  stage: build
  parallel:
    matrix:
@@ -248,7 +246,7 @@ macos:
    - curl -L $CI_API_V4_URL/projects/30437/packages/generic/pkgconfig/v0.29.2+10/pkg-config-0.29.2+10_$(uname -m).tar.xz | tar -C .venv -xJ
    - curl -L $CI_API_V4_URL/projects/30438/packages/generic/bison/v3.8.2+3/bison-3.8.2+3_$(uname -m).tar.xz | tar -C .venv -xJ
    - source .venv/bin/activate
-    - pip3 install meson==1.3.2 $NINJA_PKG
+    - pip3 install meson==1.3.2 ninja==1.11.1.1
    # We're not setting up ccache here on purpose as it accelerates the build
    # so much that it triggers race conditions in the gobject-introspection
    # subproject.
@@ -2,6 +2,8 @@ FROM fedora:39

 RUN dnf -y install \
    adwaita-icon-theme \
+    atk-devel \
+    at-spi2-atk-devel \
    avahi-gobject-devel \
    cairo-devel \
    cairo-gobject-devel \
@@ -16,6 +18,7 @@ RUN dnf -y install \
    dejavu-sans-mono-fonts \
    desktop-file-utils \
    diffutils \
+    docbook-style-xsl \
    elfutils-libelf-devel \
    expat-devel \
    fribidi-devel \
@@ -19,6 +19,7 @@ flatpak build ${builddir} meson \
                --buildtype=debugoptimized \
                -Dx11-backend=true \
                -Dwayland-backend=true \
+                -Dvulkan=disabled \
                -Dbuild-tests=false \
                -Dbuild-testsuite=false \
                -Dbuild-examples=false \
@@ -1,154 +1,11 @@
-Overview of Changes in 4.14.2, xx-xx-xxxx
-=========================================
-
-Overview of Changes in 4.14.1, 16-03-2024
-=========================================
-
-* GtkTextView:
- - Fix a mixup of cursor and anchor when retrieving surrounding text
-   in input methods
-
-* Printing:
- - Avoid accessing freed printers
-
-* Accessibility:
- - Fix memory leaks
-
-* GDK:
- - Rename the GDK_VULKAN_SKIP environment variable to GDK_VULKAN_DISABLE
- - Add a GDK_GL_DISABLE environment variable
-
-* GSK:
- - Rename the GSK_GPU_SKIP environment variable to GSK_GPU_DISABLE
- - Speed up handling of repeated ops, which should help for text
- - Speed up the inner loop of text node conversion
- - Drop the glyph-align optimization flag
- - ngl: Avoid reusing frames while they are in use
- - Fix flickering thumbnails in nautilus
- - Speed up buffer handling in both ngl and Vulkan
-
-* Demos:
- - Skip demos using gl shaders when we're not using the gl renderer
-
-* Build:
- - Fix some ubsan warnings
- - Avoid zink in ci since it spams stderr
-
-* Translation updates:
- Czech
- German
- Korean
- Russian
-
-
-Overview of Changes in 4.14.0, 12-03-2024
+Overview of Changes in 4.13.9, xx-xx-xxxx
 =========================================

 Note: The new renderers and dmabuf support are using graphics drivers
 in different ways than the old gl renderer, and trigger new driver bugs,
 (see for example https://gitlab.gnome.org/GNOME/gtk/-/issues/6418 and
 https://gitlab.gnome.org/GNOME/gtk/-/issues/6388). Therefore, it is
-recommended to use the latest mesa release (24.x) with the new renderers.
-
-* GtkTextView:
- - Don't snapshot children twice
- - Don't blink the cursor when hidden
-
-* GtkEmojiChooser:
- - Fix presentation selector handling
-
-* GtkSnapshot:
- - Fix wrong nodes with transformed shadows
-
-* GtkIMContext:
- - Make gtk_im_context_activate_osk public
-
-* Accessibility:
- - Implement get_contents_at for all our text widgets
- - Add GtkAccessibleText.get_default_attributes
-
-* GSK:
- - Don't fall back to cairo for software rendering. gl+llvmpipe is better
- - Round vertical glyph position to a device pixel position if the font is hinted
- - Fix problems with clip handling
- - Make vulkan and ngl match their font handling
- - Fix some corner-cases with offloading and clips
- - Fix problem with rendering of missing glyphs in hinted fonts
-
-* MacOs:
- - Implement cursor-from-texture
-
-* Translation updates:
- Basque
- British English
- French
- Indonesian
- Kazakh
- Latvian
- Lithuanian
- Norwegian Bokmål
- Slovenian
- Spanish
- Turkish
-
-
-Overview of Changes in 4.13.9, 02-03-2024
-=========================================
-
-* GtkEditable:
- - Fix preconditions to be not too strict
-
-* GtkEmojiChooser:
- - Support search in the locale as well as in English
-
-* GtkIconTheme:
- - Make gtk_icon_paintable_new_for_file support symbolics
-
-* GtkVideo:
- - Fix a problem with cursor handling that could lead to crashes
-
-* Accessibility:
- - Fix GetCharacterAtOffset implementation
- - Add a Terminal role
- - Make TextCaretMoved match gtk3
- - Support multiple levels of GtkEditable delegates
-
-* GSK:
- - Make the node parser more flexible for text nodes
- - Change the way font scaling is handled to avoid clipping
- - Fix handling of missing glyphs in the new renderers
-
-* X11:
- - Don't claim to support shadows without a compositor
-
-* Wayland:
- - Fix handling of output scales
-
-* Tools:
- - Add a compare command to gtk4-rendernode-tool
-
-* Build:
- - Fix some ubsan complaints
-
-* Translation updates:
- Basque
- British English
- Catalan
- Finnish
- Galician
- Georgian
- Hebrew
- Indonesian
- Kazakh
- Latvian
- Lithuanian
- Persian
- Polish
- Russian
- Slovenian
- Spanish
- Turkish
- Ukrainian
+recommended to use the latest mesa release (24.0) with the new renderers.


 Overview of Changes in 4.13.8, 20-02-2024
@@ -185,6 +185,7 @@
            "builddir" : true,
            "config-opts" : [
                "--libdir=/app/lib",
+                "-Dvulkan=disabled",
                "-Dbuildtype=debugoptimized",
                "-Ddemo-profile=devel"
            ],
@@ -114,6 +114,7 @@
            "builddir" : true,
            "config-opts" : [
                "--libdir=/app/lib",
+                "-Dvulkan=disabled",
                "-Dbuildtype=debugoptimized",
                "-Ddemo-profile=devel"
            ],
@@ -114,6 +114,7 @@
            "builddir" : true,
            "config-opts" : [
                "--libdir=/app/lib",
+                "-Dvulkan=disabled",
                "-Dbuildtype=debugoptimized",
                "-Ddemo-profile=devel"
            ],
@@ -130,6 +131,7 @@
        "env" : {
            "DBUS_SESSION_BUS_ADDRESS" : "''",
            "GSK_RENDERER" : "opengl",
+            "GDK_DEBUG" : "vulkan-disable",
            "G_ENABLE_DEBUG" : "true"
        }
    }
@@ -114,6 +114,7 @@
            "builddir" : true,
            "config-opts" : [
                "--libdir=/app/lib",
+                "-Dvulkan=disabled",
                "-Dbuildtype=debugoptimized",
                "-Ddemo-profile=devel"
            ],
@@ -130,6 +131,7 @@
        "env" : {
            "DBUS_SESSION_BUS_ADDRESS" : "''",
            "GSK_RENDERER" : "opengl",
+            "GDK_DEBUG" : "vulkan-disable",
            "G_ENABLE_DEBUG" : "true"
        }
    }
@@ -184,12 +184,6 @@ create_cogs (void)
  return picture;
 }

-static gboolean
-check_cogs (GtkFishbowl *fb)
-{
-  return GSK_IS_GL_RENDERER (gtk_native_get_renderer (gtk_widget_get_native (GTK_WIDGET (fb))));
-}
-
 static void
 mapped (GtkWidget *w)
 {
@@ -224,41 +218,36 @@ create_graph (void)

 static const struct {
  const char *name;
-  GtkWidget * (* create_func) (void);
-  gboolean    (* check) (GtkFishbowl *fb);
+  GtkWidget * (*create_func) (void);
 } widget_types[] = {
-  { "Icon",       create_icon,           NULL },
-  { "Button",     create_button,         NULL },
-  { "Blurbutton", create_blurred_button, NULL },
-  { "Fontbutton", create_font_button,    NULL },
-  { "Levelbar",   create_level_bar,      NULL },
-  { "Label",      create_label,          NULL },
-  { "Spinner",    create_spinner,        NULL },
-  { "Spinbutton", create_spinbutton,     NULL },
-  { "Video",      create_video,          NULL },
-  { "Gears",      create_gears,          NULL },
-  { "Switch",     create_switch,         NULL },
-  { "Menubutton", create_menu_button,    NULL },
-  { "Shader",     create_cogs,           check_cogs },
-  { "Tiger",      create_tiger,          NULL },
-  { "Graph",      create_graph,          NULL },
+  { "Icon",       create_icon           },
+  { "Button",     create_button         },
+  { "Blurbutton", create_blurred_button },
+  { "Fontbutton", create_font_button    },
+  { "Levelbar",   create_level_bar      },
+  { "Label",      create_label          },
+  { "Spinner",    create_spinner        },
+  { "Spinbutton", create_spinbutton     },
+  { "Video",      create_video          },
+  { "Gears",      create_gears          },
+  { "Switch",     create_switch         },
+  { "Menubutton", create_menu_button    },
+  { "Shader",     create_cogs           },
+  { "Tiger",      create_tiger          },
+  { "Graph",      create_graph          },
 };

 static int selected_widget_type = -1;
 static const int N_WIDGET_TYPES = G_N_ELEMENTS (widget_types);

-static gboolean
+static void
 set_widget_type (GtkFishbowl *fishbowl,
                 int          widget_type_index)
 {
  GtkWidget *window;

  if (widget_type_index == selected_widget_type)
-    return TRUE;
-
-  if (widget_types[widget_type_index].check != NULL &&
-      !widget_types[widget_type_index].check (fishbowl))
-    return FALSE;
+    return;

  selected_widget_type = widget_type_index;

@@ -268,8 +257,6 @@ set_widget_type (GtkFishbowl *fishbowl,
  window = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (fishbowl)));
  gtk_window_set_title (GTK_WINDOW (window),
                        widget_types[selected_widget_type].name);
-
-  return TRUE;
 }

 G_MODULE_EXPORT void
@@ -277,17 +264,14 @@ fishbowl_next_button_clicked_cb (GtkButton *source,
                                 gpointer   user_data)
 {
  GtkFishbowl *fishbowl = user_data;
-  int new_index = selected_widget_type;
+  int new_index;

-  do
-    {
-      if (new_index + 1 >= N_WIDGET_TYPES)
-        new_index = 0;
-      else
-        new_index = new_index + 1;
+  if (selected_widget_type + 1 >= N_WIDGET_TYPES)
+    new_index = 0;
+  else
+    new_index = selected_widget_type + 1;

-    }
-  while (!set_widget_type (fishbowl, new_index));
+  set_widget_type (fishbowl, new_index);
 }

 G_MODULE_EXPORT void
@@ -295,18 +279,14 @@ fishbowl_prev_button_clicked_cb (GtkButton *source,
                                 gpointer   user_data)
 {
  GtkFishbowl *fishbowl = user_data;
-  int new_index = selected_widget_type;
+  int new_index;

-  do
-    {
-      if (new_index - 1 < 0)
-        new_index = N_WIDGET_TYPES - 1;
-      else
-        new_index = new_index - 1;
+  if (selected_widget_type - 1 < 0)
+    new_index = N_WIDGET_TYPES - 1;
+  else
+    new_index = selected_widget_type - 1;

-    }
-
-  while (!set_widget_type (fishbowl, new_index));
+  set_widget_type (fishbowl, new_index);
 }

 G_MODULE_EXPORT void
@@ -600,8 +600,8 @@ update_display (void)
  if (s->len > 0)
    {
      pango_font_description_set_variations (desc, s->str);
+      g_string_free (s, TRUE);
    }
-  g_string_free (s, TRUE);

  font_desc = pango_font_description_to_string (desc);

@@ -116,9 +116,7 @@ static gboolean gtk_shadertoy_tick          (GtkWidget     *widget,
 GtkWidget *
 gtk_shadertoy_new (void)
 {
-  return g_object_new (gtk_shadertoy_get_type (),
-                       "allowed-apis", GDK_GL_API_GL,
-                       NULL);
+  return g_object_new (gtk_shadertoy_get_type (), NULL);
 }

 static void
@@ -354,7 +354,6 @@ do_images (GtkWidget *do_widget)
      gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
      image = gtk_image_new_from_gicon (gicon);
      gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
-      g_object_unref (gicon);

      gtk_frame_set_child (GTK_FRAME (frame), image);

@@ -827,25 +827,13 @@ demo_search_changed_cb (GtkSearchEntry *entry,
  gtk_filter_changed (filter, GTK_FILTER_CHANGE_DIFFERENT);
 }

-static gboolean
-demo_can_run (GtkWidget  *window,
-              const char *name)
-{
-  if (name != NULL && strcmp (name, "gltransition") == 0)
-    return GSK_IS_GL_RENDERER (gtk_native_get_renderer (GTK_NATIVE (window)));
-
-  return TRUE;
-}
-
 static GListModel *
-create_demo_model (GtkWidget *window)
+create_demo_model (void)
 {
  GListStore *store = g_list_store_new (GTK_TYPE_DEMO);
  DemoData *demo = gtk_demos;
  GtkDemo *d;

-  gtk_widget_realize (window);
-
  d = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
  d->name = "main";
  d->title = "GTK Demo";
@@ -857,20 +845,16 @@ create_demo_model (GtkWidget *window)

  while (demo->title)
    {
-       DemoData *children = demo->children;
+      d = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
+      DemoData *children = demo->children;

-      if (demo_can_run (window, demo->name))
-        {
-          d = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
+      d->name = demo->name;
+      d->title = demo->title;
+      d->keywords = demo->keywords;
+      d->filename = demo->filename;
+      d->func = demo->func;

-          d->name = demo->name;
-          d->title = demo->title;
-          d->keywords = demo->keywords;
-          d->filename = demo->filename;
-          d->func = demo->func;
-
-          g_list_store_append (store, d);
-        }
+      g_list_store_append (store, d);

      if (children)
        {
@@ -878,19 +862,15 @@ create_demo_model (GtkWidget *window)

          while (children->title)
            {
-              if (demo_can_run (window, children->name))
-                {
-                  GtkDemo *child = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
+              GtkDemo *child = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));

-                  child->name = children->name;
-                  child->title = children->title;
-                  child->keywords = children->keywords;
-                  child->filename = children->filename;
-                  child->func = children->func;
-
-                  g_list_store_append (G_LIST_STORE (d->children_model), child);
-                }
+              child->name = children->name;
+              child->title = children->title;
+              child->keywords = children->keywords;
+              child->filename = children->filename;
+              child->func = children->func;

+              g_list_store_append (G_LIST_STORE (d->children_model), child);
              children++;
            }
        }
@@ -956,7 +936,7 @@ activate (GApplication *app)
  search_bar = GTK_WIDGET (gtk_builder_get_object (builder, "searchbar"));
  g_signal_connect (search_bar, "notify::search-mode-enabled", G_CALLBACK (clear_search), NULL);

-  listmodel = create_demo_model (window);
+  listmodel = create_demo_model ();
  treemodel = gtk_tree_list_model_new (G_LIST_MODEL (listmodel),
                                       FALSE,
                                       TRUE,
@@ -2,7 +2,7 @@
 <interface>
  <menu id="menubar">
    <submenu>
-      <attribute name="label" translatable="yes">_File</attribute>
+      <attribute name="label" translatable="yes">_Application</attribute>
      <section>
        <item>
          <attribute name="label" translatable="yes">_New</attribute>
@@ -33,7 +33,7 @@
      </section>
    </submenu>
    <submenu>
-      <attribute name="label" translatable="yes">_Preferences</attribute>
+      <attribute name="label" translatable="yes">_File</attribute>
      <section>
        <item>
          <attribute name="label" translatable="yes">_Prefer Dark Theme</attribute>
@@ -338,7 +338,7 @@ do_path_maze (GtkWidget *do_widget)
      GskPath *path;

      window = gtk_window_new ();
-      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
      gtk_window_set_title (GTK_WINDOW (window), "Follow the maze with the mouse");
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);

@@ -322,14 +322,12 @@ stroke bounds of the path.

 ### text

-| property     | syntax              | default             | printed     |
-| ------------ | ------------------- | ------------------- | ----------- |
-| color        | `<color>`           | black               | non-default |
-| font         | `<string>` `<url>`? | "Cantarell 15px"    | always      |
-| glyphs       | `<glyphs>`          | "Hello"             | always      |
-| offset       | `<point>`           | 0 0                 | non-default |
-| hint-style   | `<hint style>`      | slight              | non-default |
-| antialias    | `<antialias>`       | gray                | non-default |
+| property | syntax              | default             | printed     |
+| -------- | ------------------- | ------------------- | ----------- |
+| color    | `<color>`           | black               | non-default |
+| font     | `<string>` `<url>`? | "Cantarell 11"      | always      |
+| glyphs   | `<glyphs>`          | "Hello"             | always      |
+| offset   | `<point>`           | 0 0                 | non-default |

 Creates a node like `gsk_text_node_new()` with the given properties.

@@ -338,15 +336,12 @@ font that is specified in the string. It can be either a data url containing
 a base64-encoded font file, or a regular url that points to a font file.

 Glyphs can be specified as an ASCII string, or as a comma-separated list of
-their glyph IDs. Optionally, the advance width, x and y offsets and flags can
+their glyph ID and advance width. Optionally, x and y offsets and flags can
 be specified as well, like this: 40 10 0 0 color.

 If the given font does not exist or the given glyphs are invalid for the given
 font, an error node will be returned.

-Possible values for hint-style are none, slight or full.
-Possible value for antialias are none or gray.
-
 ### texture

 | property | syntax              | default                | printed     |
@@ -69,9 +69,9 @@ Image:
 4			CARD32		IMAGE_DATA_OFFSET	

 ICON_FLAGS
-HAS_SUFFIX_XPM	1
-HAS_SUFFIX_SVG	2
-HAS_SUFFIX_PNG	4
+HAS_SUFFIX_PNG	1
+HAS_SUFFIX_XPM	2
+HAS_SUFFIX_SVG	4
 HAS_ICON_FILE	8

 ImageData:
@@ -38,13 +38,13 @@ can run the build, using Ninja:

 ```
 cd builddir
-meson compile
-meson install
+ninja
+ninja install
 ```

 If you don't have permission to write to the directory you are
 installing in, you may have to change to root temporarily before
-running `meson install`.
+running `ninja install`.

 Several environment variables are useful to pass to set before
 running *meson*. `CPPFLAGS` contains options to pass to the C
@@ -112,10 +112,10 @@ responsible for controlling the debugging features of GTK with

 ## Dependencies

-Before you can compile GTK, you need to have various other tools and
-libraries installed on your system. Dependencies of GTK have their own
-build systems, so you will need to refer to their own installation
-instructions.
+Before you can compile the GTK widget toolkit, you need to have
+various other tools and libraries installed on your
+system. Dependencies of GTK have their own build systems, so
+you will need to refer to their own installation instructions.

 A particular important tool used by GTK to find its dependencies
 is `pkg-config`.
@@ -156,8 +156,8 @@ Other libraries are maintained separately.
  the development environment for these libraries that your
  operating system vendor provides.
 - The [fontconfig](https://www.freedesktop.org/wiki/Software/fontconfig/)
-  library provides Pango with a standard way of locating fonts and matching
-  them against font names.
+  library provides Pango with a standard way of locating
+  fonts and matching them against font names.
 - [Cairo](https://www.cairographics.org) is a graphics library that
  supports vector graphics and image compositing. Both Pango and GTK
  use Cairo for drawing. Note that we also need the auxiliary cairo-gobject
@@ -220,12 +220,13 @@ meson configure builddir

 ### `x11-backend`, `win32-backend`, `broadway-backend`, `wayland-backend` and `macos-backend`

-Enable specific backends for GDK.  If none of these options are given, the
-Wayland backend will be enabled by default, if the platform is Linux; the
-X11 backend will also be enabled by default, unless the platform is Windows,
-in which case the default is win32, or the platform is macOS, in which case
-the default is macOS. If any backend is explicitly enabled or disabled, no
-other platform will be enabled automatically.
+Enable specific backends for GDK.  If none of these options
+are given, the Wayland backend will be enabled by default,
+if the platform is Linux; the X11 backend will also be enabled
+by default, unless the platform is Windows, in which case the
+default is win32, or the platform is macOS, in which case the
+default is macOS. If any backend is explicitly enabled or disabled,
+no other platform will be enabled automatically.

 ### `vulkan`

@@ -1,7 +1,7 @@
 Title: CSS in GTK
 Slug: css

-This chapter describes how GTK uses CSS for styling and layout.
+This chapter describes how GTK uses CSS for styling and layout. 
 It is not meant to be an explanation of CSS from first principles,
 but focuses on listing supported CSS features and differences
 between Web CSS and GTK.
@@ -28,9 +28,6 @@ GTK depends on the following libraries:
 - **OpenGL**: OpenGL is the premier environment for developing portable,
   interactive 2D and 3D graphics applications. More information available
   on the [Khronos website][opengl].
- - **Vulkan**: Vulkan is the a newer graphics API, that can be considered
-   the successor of OpenGL.  More information available on the
-   [Khronos website][vulkan].
 - **Pango**: Pango is a library for internationalized text handling. It
   centers around the `PangoLayout` object, representing a paragraph of
   text.  Pango provides the engine for `GtkTextView`, `GtkLabel`,
@@ -63,7 +60,6 @@ GTK is divided into three parts:
 [gio]: https://developer.gnome.org/gio/stable/
 [cairo]: https://www.cairographics.org/manual/
 [opengl]: https://www.opengl.org/about/
-[vulkan]: https://www.vulkan.org/
 [pango]: https://pango.gnome.org/
 [gdkpixbuf]: https://developer.gnome.org/gdk-pixbuf/stable/
 [graphene]: https://ebassi.github.io/graphene/
@@ -278,11 +278,14 @@ are only available when GTK has been configured with `-Ddebug=true`.
 : OpenGL renderer information

 `vulkan`
-: Check Vulkan errors
+: Vulkan renderer information

 `shaders`
 : Information about shaders

+`surface`
+: Information about surfaces
+
 `fallback`
 : Information about fallback usage in renderers

@@ -300,6 +303,9 @@ A number of options affect behavior instead of logging:
 `full-redraw`
 : Force full redraws

+`sync`
+: Sync after each frame
+
 `staging`
 : Use a staging image for texture upload (Vulkan only)

@@ -341,28 +347,6 @@ a `*`, which means: try all remaining backends. The special value
 backends. For more information about selecting backends,
 see the [func@Gdk.DisplayManager.get] function.

-### `GDK_GL_DISABLE`
-
-This variable can be set to a list of values, which cause GDK to
-disable extension features of the OpenGL support.
-Note that these features may already be disabled if the GL driver
-does not support them.
-
-`debug`
-: GL_KHR_debug
-
-`unpack-subimage`
-:GL_EXT_unpack_subimage
-
-`half-float`
-:GL_OES_vertex_half_float
-
-`sync`
-:GL_ARB_sync
-
-`base-instance`
-:GL_EXT_base_instance
-
 ### `GDK_VULKAN_DEVICE`

 This variable can be set to the index of a Vulkan device to override
@@ -370,7 +354,7 @@ the default selection of the device that is used for Vulkan rendering.
 The special value `list` can be used to obtain a list of all Vulkan
 devices.

-### `GDK_VULKAN_DISABLE`
+### `GDK_VULKAN_SKIP`

 This variable can be set to a list of values, which cause GDK to
 disable features of the Vulkan support.
@@ -450,7 +434,7 @@ using and the GDK backend supports them:
    installation.


-### `GSK_GPU_DISABLE`
+### `GSK_GPU_SKIP`

 This variable can be set to a list of values, which cause GSK to
 disable certain optimizations of the "ngl" and "vulkan" renderer.
@@ -470,6 +454,9 @@ disable certain optimizations of the "ngl" and "vulkan" renderer.
 `mipmap`
 : Avoid creating mipmaps

+`gl-baseinstance`
+: Assume no ARB/EXT_base_instance support
+
 The special value `all` can be used to turn on all values. The special
 value `help` can be used to obtain a list of all supported values.

@@ -482,10 +469,10 @@ n seconds. The default timeout is 15 seconds.

 ### `GSK_MAX_TEXTURE_SIZE`

-Limit texture size to the minimum of this value and the OpenGL limit for
-texture sizes in the "gl" renderer. This can be used to debug issues with
-texture slicing on systems where the OpenGL texture size limit would
-otherwise make texture slicing difficult to test.
+Limit texture size to the minimum of this value and the OpenGL limit
+for texture sizes. This can be used to debug issues with texture slicing
+on systems where the OpenGL texture size limit would otherwise make
+texture slicing difficult to test.

 ### `GTK_CSD`

@@ -1538,7 +1538,6 @@ describe_egl_config (EGLDisplay egl_display,
                     EGLConfig  egl_config)
 {
  EGLint red, green, blue, alpha, type;
-  EGLint depth, stencil;

  if (egl_config == NULL)
    return g_strdup ("-");
@@ -1557,15 +1556,7 @@ describe_egl_config (EGLDisplay egl_display,
  else
    type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;

-  if (!eglGetConfigAttrib (egl_display, egl_config, EGL_DEPTH_SIZE, &depth))
-    depth = 0;
-  if (!eglGetConfigAttrib (egl_display, egl_config, EGL_STENCIL_SIZE, &stencil))
-    stencil = 0;
-
-  return g_strdup_printf ("R%dG%dB%dA%d%s%s%s", red, green, blue, alpha,
-                          type == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT ? "" : " float",
-                          depth > 0 ? ", depth buffer" : "",
-                          stencil > 0 ? ", stencil buffer" : "");
+  return g_strdup_printf ("R%dG%dB%dA%d%s", red, green, blue, alpha, type == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT ? "" : " float");
 }

 gpointer
@@ -2046,12 +2037,9 @@ gdk_display_get_dmabuf_formats (GdkDisplay *display)
 GdkDebugFlags
 gdk_display_get_debug_flags (GdkDisplay *display)
 {
-  if (display == NULL)
-    return _gdk_debug_flags;
-
  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);

-  return priv->debug_flags;
+  return display ? priv->debug_flags : _gdk_debug_flags;
 }

 void
@@ -50,6 +50,18 @@
 #include "gdkenumtypes.h"
 #include "gdkeventsprivate.h"

+static struct {
+  GdkDragAction action;
+  const char   *name;
+  GdkCursor    *cursor;
+} drag_cursors[] = {
+  { GDK_ACTION_ASK,     "dnd-ask",  NULL },
+  { GDK_ACTION_COPY,    "copy", NULL },
+  { GDK_ACTION_MOVE,    "move", NULL },
+  { GDK_ACTION_LINK,    "alias", NULL },
+  { 0,                  "no-drop", NULL },
+};
+
 enum {
  PROP_0,
  PROP_CONTENT,
@@ -774,20 +786,6 @@ gdk_drag_handle_source_event (GdkEvent *event)
  return FALSE;
 }

-static struct {
-  GdkDragAction action;
-  const char   *name;
-  GdkCursor    *cursor;
-} drag_cursors[] = {
-  { 0,               "default",  NULL },
-  { GDK_ACTION_ASK,  "dnd-ask",  NULL },
-  { GDK_ACTION_COPY, "copy",     NULL },
-  { GDK_ACTION_MOVE, "dnd-move", NULL }, /* Not using move here, since move is stuck using
-                                          * a mismatched visual metaphor in Adwaita
-                                          */
-  { GDK_ACTION_LINK, "alias",    NULL },
-};
-
 GdkCursor *
 gdk_drag_get_cursor (GdkDrag       *drag,
                     GdkDragAction  action)
@@ -79,23 +79,14 @@ static guint signals[LAST_SIGNAL];

 static guint fps_counter;

-/* 60Hz plus some extra for monotonic time inaccuracy */
-#define FRAME_HISTORY_DEFAULT_LENGTH 64
-
-#define frame_timings_unref(x) gdk_frame_timings_unref((GdkFrameTimings *) (x))
-
-#define GDK_ARRAY_NAME timings
-#define GDK_ARRAY_TYPE_NAME Timings
-#define GDK_ARRAY_ELEMENT_TYPE GdkFrameTimings *
-#define GDK_ARRAY_PREALLOC FRAME_HISTORY_DEFAULT_LENGTH
-#define GDK_ARRAY_FREE_FUNC frame_timings_unref
-#include "gdk/gdkarrayimpl.c"
+#define FRAME_HISTORY_MAX_LENGTH 128

 struct _GdkFrameClockPrivate
 {
  gint64 frame_counter;
+  int n_timings;
  int current;
-  Timings timings;
+  GdkFrameTimings *timings[FRAME_HISTORY_MAX_LENGTH];
  int n_freeze_inhibitors;
 };

@@ -108,8 +99,11 @@ static void
 gdk_frame_clock_finalize (GObject *object)
 {
  GdkFrameClockPrivate *priv = GDK_FRAME_CLOCK (object)->priv;
+  int i;

-  timings_clear (&priv->timings);
+  for (i = 0; i < FRAME_HISTORY_MAX_LENGTH; i++)
+    if (priv->timings[i] != 0)
+      gdk_frame_timings_unref (priv->timings[i]);

  G_OBJECT_CLASS (gdk_frame_clock_parent_class)->finalize (object);
 }
@@ -263,8 +257,7 @@ gdk_frame_clock_init (GdkFrameClock *clock)
  clock->priv = priv = gdk_frame_clock_get_instance_private (clock);

  priv->frame_counter = -1;
-  priv->current = 0;
-  timings_init (&priv->timings);
+  priv->current = FRAME_HISTORY_MAX_LENGTH - 1;

  if (fps_counter == 0)
    fps_counter = gdk_profiler_define_counter ("fps", "Frames per Second");
@@ -423,7 +416,7 @@ gdk_frame_clock_get_frame_counter (GdkFrameClock *frame_clock)
 static inline gint64
 _gdk_frame_clock_get_history_start (GdkFrameClock *frame_clock)
 {
-  return frame_clock->priv->frame_counter + 1 - timings_get_size (&frame_clock->priv->timings);
+  return frame_clock->priv->frame_counter + 1 - frame_clock->priv->n_timings;
 }

 /**
@@ -452,44 +445,31 @@ gdk_frame_clock_get_history_start (GdkFrameClock *frame_clock)
 }

 void
-_gdk_frame_clock_begin_frame (GdkFrameClock *frame_clock,
-                              gint64         monotonic_time)
+_gdk_frame_clock_begin_frame (GdkFrameClock *frame_clock)
 {
  GdkFrameClockPrivate *priv;
+
  g_return_if_fail (GDK_IS_FRAME_CLOCK (frame_clock));

  priv = frame_clock->priv;

  priv->frame_counter++;
+  priv->current = (priv->current + 1) % FRAME_HISTORY_MAX_LENGTH;

-  if (G_UNLIKELY (timings_get_size (&priv->timings) == 0))
-    timings_append (&priv->timings, _gdk_frame_timings_new (priv->frame_counter));
+  /* Try to steal the previous frame timing instead of discarding
+   * and allocating a new one.
+   */
+  if G_LIKELY (priv->n_timings == FRAME_HISTORY_MAX_LENGTH &&
+               _gdk_frame_timings_steal (priv->timings[priv->current],
+                                         priv->frame_counter))
+    return;
+
+  if (priv->n_timings < FRAME_HISTORY_MAX_LENGTH)
+    priv->n_timings++;
  else
-    {
-      GdkFrameTimings *timings;
+    gdk_frame_timings_unref (priv->timings[priv->current]);

-      priv->current = (priv->current + 1) % timings_get_size (&priv->timings);
-
-      timings = timings_get (&priv->timings, priv->current);
-
-      if (timings->frame_time + G_USEC_PER_SEC > monotonic_time)
-        {
-          /* Keep the timings, not a second old yet */
-          timings = _gdk_frame_timings_new (priv->frame_counter);
-          timings_splice (&priv->timings, priv->current, 0, FALSE, &timings, 1);
-        }
-      else if (_gdk_frame_timings_steal (timings, priv->frame_counter))
-        {
-          /* Stole the previous frame timing instead of discarding
-           * and allocating a new one, so nothing to do
-           */
-        }
-      else
-        {
-          timings = _gdk_frame_timings_new (priv->frame_counter);
-          timings_splice (&priv->timings, priv->current, 1, FALSE, &timings, 1);
-        }
-    }
+  priv->timings[priv->current] = _gdk_frame_timings_new (priv->frame_counter);
 }

 static inline GdkFrameTimings *
@@ -497,21 +477,17 @@ _gdk_frame_clock_get_timings (GdkFrameClock *frame_clock,
                              gint64         frame_counter)
 {
  GdkFrameClockPrivate *priv = frame_clock->priv;
-  gsize size, pos;
+  int pos;

  if (frame_counter > priv->frame_counter)
    return NULL;

-  size = timings_get_size (&priv->timings);
-  if (G_UNLIKELY (size == 0))
+  if (frame_counter <= priv->frame_counter - priv->n_timings)
    return NULL;

-  if (priv->frame_counter - frame_counter >= size)
-    return NULL;
+  pos = (priv->current - (priv->frame_counter - frame_counter) + FRAME_HISTORY_MAX_LENGTH) % FRAME_HISTORY_MAX_LENGTH;

-  pos = (priv->current - (priv->frame_counter - frame_counter) + size) % size;
-
-  return timings_get (&priv->timings, pos);
+  return priv->timings[pos];
 }

 /**
@@ -803,10 +779,7 @@ gdk_frame_clock_get_fps (GdkFrameClock *frame_clock)

  start_counter = _gdk_frame_clock_get_history_start (frame_clock);
  end_counter = _gdk_frame_clock_get_frame_counter (frame_clock);
-  for (start = _gdk_frame_clock_get_timings (frame_clock, start_counter);
-       end_counter > start_counter && start != NULL && !gdk_frame_timings_get_complete (start);
-       start = _gdk_frame_clock_get_timings (frame_clock, start_counter))
-    start_counter++;
+  start = _gdk_frame_clock_get_timings (frame_clock, start_counter);
  for (end = _gdk_frame_clock_get_timings (frame_clock, end_counter);
       end_counter > start_counter && end != NULL && !gdk_frame_timings_get_complete (end);
       end = _gdk_frame_clock_get_timings (frame_clock, end_counter))
@@ -192,13 +192,6 @@ compute_smooth_frame_time (GdkFrameClock *clock,
   *        and new_frame_time >= old_frame_time. */
  frames_passed = (new_frame_time - smoothed_frame_time_base + frame_interval / 2) / frame_interval;

-  if (frames_passed > 1)
-    gdk_profiler_add_markf ((smoothed_frame_time_base - (frame_interval * (frames_passed-1))) * 1000L,
-                            frame_interval * (frames_passed-1) * 1000L,
-                            "Dropped Frames",
-                            "%u frames may have been dropped",
-                            frames_passed-1);
-
  /* We use an approximately whole number of frames in the future from
   * last smoothed frame time. This way we avoid minor jitter in the
   * frame times making the animation speed uneven, but still animate
@@ -555,7 +548,7 @@ gdk_frame_clock_paint_idle (void *data)
              priv->smoothed_frame_time_period = frame_interval;
              priv->smoothed_frame_time_reported = priv->smoothed_frame_time_base;

-              _gdk_frame_clock_begin_frame (clock, priv->frame_time);
+              _gdk_frame_clock_begin_frame (clock);
              /* Note "current" is different now so timings != prev_timings */
              timings = gdk_frame_clock_get_current_timings (clock);

@@ -106,8 +106,7 @@ struct _GdkFrameTimings
 void _gdk_frame_clock_inhibit_freeze (GdkFrameClock *clock);
 void _gdk_frame_clock_uninhibit_freeze (GdkFrameClock *clock);

-void _gdk_frame_clock_begin_frame         (GdkFrameClock   *clock,
-                                           gint64           monotonic_time);
+void _gdk_frame_clock_begin_frame         (GdkFrameClock   *clock);
 void _gdk_frame_clock_debug_print_timings (GdkFrameClock   *clock,
                                           GdkFrameTimings *timings);
 void _gdk_frame_clock_add_timings_to_profiler (GdkFrameClock *frame_clock,
@@ -125,7 +125,7 @@ gdk_cairo_draw_from_gl (cairo_t              *cr,
   * the GL_UNPACK_ROW_LENGTH support
   */
  if (gdk_gl_context_get_use_es (paint_context) &&
-      !(version >= 300 || gdk_gl_context_has_feature (paint_context, GDK_GL_FEATURE_UNPACK_SUBIMAGE)))
+      !(version >= 300 || gdk_gl_context_has_unpack_subimage (paint_context)))
    return;

  /* TODO: avoid reading back non-required data due to dest clip */
@@ -103,15 +103,6 @@

 #define DEFAULT_ALLOWED_APIS GDK_GL_API_GL | GDK_GL_API_GLES

-static const GdkDebugKey gdk_gl_feature_keys[] = {
-  { "debug", GDK_GL_FEATURE_DEBUG, "GL_KHR_debug" },
-  { "unpack-subimage", GDK_GL_FEATURE_UNPACK_SUBIMAGE, "GL_EXT_unpack_subimage" },
-  { "half-float", GDK_GL_FEATURE_VERTEX_HALF_FLOAT, "GL_OES_vertex_half_float" },
-  { "sync", GDK_GL_FEATURE_SYNC, "GL_ARB_sync" },
-  { "base-instance", GDK_GL_FEATURE_BASE_INSTANCE, "GL_ARB_base_instance" },
-  { "buffer-storage", GDK_GL_FEATURE_BUFFER_STORAGE, "GL_EXT_buffer_storage" },
-};
-
 typedef struct _GdkGLContextPrivate GdkGLContextPrivate;

 struct _GdkGLContextPrivate
@@ -121,9 +112,13 @@ struct _GdkGLContextPrivate

  GdkGLMemoryFlags memory_flags[GDK_MEMORY_N_FORMATS];

-  GdkGLFeatures features;
+  guint has_khr_debug : 1;
  guint use_khr_debug : 1;
+  guint has_half_float : 1;
+  guint has_sync : 1;
+  guint has_unpack_subimage : 1;
  guint has_debug_output : 1;
+  guint has_bgra : 1;
  guint extensions_checked : 1;
  guint debug_enabled : 1;
  guint forward_compatible : 1;
@@ -295,7 +290,7 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
  GdkDisplay *display = gdk_gl_context_get_display (context);
  EGLDisplay egl_display = gdk_display_get_egl_display (display);
  GdkGLContext *share = gdk_display_get_gl_context (display);
-  GdkGLContextPrivate *share_priv = share ? gdk_gl_context_get_instance_private (share) : NULL;
+  GdkGLContextPrivate *share_priv = gdk_gl_context_get_instance_private (share);
  EGLConfig egl_config;
  EGLContext ctx;
  EGLint context_attribs[N_EGL_ATTRS], i = 0, flags = 0;
@@ -663,7 +658,6 @@ gdk_gl_context_real_end_frame (GdkDrawContext *draw_context,
  GdkSurface *surface = gdk_gl_context_get_surface (context);
  GdkDisplay *display = gdk_surface_get_display (surface);
  EGLSurface egl_surface;
-  G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME;

  if (priv->egl_context == NULL)
    return;
@@ -672,6 +666,8 @@ gdk_gl_context_real_end_frame (GdkDrawContext *draw_context,

  egl_surface = gdk_surface_get_egl_surface (surface);

+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "EGL swap buffers", NULL);
+
  if (priv->eglSwapBuffersWithDamage)
    {
      EGLint stack_rects[4 * 4]; /* 4 rects */
@@ -702,8 +698,6 @@ gdk_gl_context_real_end_frame (GdkDrawContext *draw_context,
  else
    eglSwapBuffers (gdk_display_get_egl_display (display), egl_surface);
 #endif
-
-  gdk_profiler_add_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "EGL swap buffers", NULL);
 }

 static void
@@ -903,12 +897,11 @@ gdk_gl_context_label_object_printf  (GdkGLContext *context,


 gboolean
-gdk_gl_context_has_feature (GdkGLContext  *self,
-                            GdkGLFeatures  feature)
+gdk_gl_context_has_unpack_subimage (GdkGLContext *context)
 {
-  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);

-  return (priv->features & feature) == feature;
+  return priv->has_unpack_subimage;
 }

 static gboolean
@@ -1670,53 +1663,10 @@ gdk_gl_version_init_epoxy (GdkGLVersion *version)
  *version = GDK_GL_VERSION_INIT (epoxy_version / 10, epoxy_version % 10);
 }

-static GdkGLFeatures
-gdk_gl_context_check_features (GdkGLContext *context)
-{
-  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
-  GdkGLFeatures features = 0;
-
-  if (gdk_gl_context_get_use_es (context))
-    {
-      if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)) ||
-          epoxy_has_gl_extension ("GL_EXT_unpack_subimage"))
-        features |= GDK_GL_FEATURE_UNPACK_SUBIMAGE;
-    }
-  else
-    {
-      features |= GDK_GL_FEATURE_UNPACK_SUBIMAGE;
-    }
-
-  if (epoxy_has_gl_extension ("GL_KHR_debug"))
-    features |= GDK_GL_FEATURE_DEBUG;
-
-  if (gdk_gl_context_check_version (context, "3.0", "3.0") ||
-      epoxy_has_gl_extension ("GL_OES_vertex_half_float"))
-    features |= GDK_GL_FEATURE_VERTEX_HALF_FLOAT;
-
-  if (gdk_gl_context_check_version (context, "3.2", "3.0") ||
-      epoxy_has_gl_extension ("GL_ARB_sync") ||
-      epoxy_has_gl_extension ("GL_APPLE_sync"))
-    features |= GDK_GL_FEATURE_SYNC;
-
-  if (gdk_gl_context_check_version (context, "4.2", "9.9") ||
-      epoxy_has_gl_extension ("GL_EXT_base_instance") ||
-      epoxy_has_gl_extension ("GL_ARB_base_instance"))
-    features |= GDK_GL_FEATURE_BASE_INSTANCE;
-
-  if (gdk_gl_context_check_version (context, "4.4", "9.9") ||
-      epoxy_has_gl_extension ("GL_EXT_buffer_storage") ||
-      epoxy_has_gl_extension ("GL_ARB_buffer_storage"))
-    features |= GDK_GL_FEATURE_BUFFER_STORAGE;
-
-  return features;
-}
-
 static void
 gdk_gl_context_check_extensions (GdkGLContext *context)
 {
  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
-  GdkGLFeatures supported_features, disabled_features;
  gboolean gl_debug = FALSE;
  GdkDisplay *display;

@@ -1734,54 +1684,69 @@ gdk_gl_context_check_extensions (GdkGLContext *context)

  if (priv->has_debug_output && gl_debug)
    {
+      gdk_gl_context_make_current (context);
      glEnable (GL_DEBUG_OUTPUT);
      glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
      glDebugMessageCallback (gl_debug_message_callback, NULL);
    }

-  /* If we asked for a core profile, but didn't get one, we're in legacy mode */
-  if (!gdk_gl_context_get_use_es (context) &&
-      !gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
-    priv->is_legacy = TRUE;
+  if (gdk_gl_context_get_use_es (context))
+    {
+      priv->has_unpack_subimage = gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)) ||
+                                  epoxy_has_gl_extension ("GL_EXT_unpack_subimage");
+      priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
+      priv->has_bgra = epoxy_has_gl_extension ("GL_EXT_texture_format_BGRA8888");
+    }
+  else
+    {
+      priv->has_unpack_subimage = TRUE;
+      priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
+      priv->has_bgra = TRUE;

-  supported_features = gdk_gl_context_check_features (context);
-  disabled_features = gdk_parse_debug_var ("GDK_GL_DISABLE",
-                                           gdk_gl_feature_keys,
-                                           G_N_ELEMENTS (gdk_gl_feature_keys));
+      /* We asked for a core profile, but we didn't get one, so we're in legacy mode */
+      if (!gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
+        priv->is_legacy = TRUE;
+    }

-  priv->features = supported_features & ~disabled_features;
-
-  gdk_gl_context_init_memory_flags (context);
-
-  if ((priv->features & GDK_GL_FEATURE_DEBUG) && gl_debug)
+  if (priv->has_khr_debug && gl_debug)
    {
      priv->use_khr_debug = TRUE;
      glGetIntegerv (GL_MAX_LABEL_LENGTH, &priv->max_debug_label_length);
    }

-  if (GDK_DISPLAY_DEBUG_CHECK (display, OPENGL))
-    {
-      int i, max_texture_size;
-      glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_texture_size);
-      gdk_debug_message ("%s version: %d.%d (%s)\n"
-                         "* GLSL version: %s\n"
-                         "* Max texture size: %d\n",
-                         gdk_gl_context_get_use_es (context) ? "OpenGL ES" : "OpenGL",
-                         gdk_gl_version_get_major (&priv->gl_version), gdk_gl_version_get_minor (&priv->gl_version),
-                         priv->is_legacy ? "legacy" : "core",
-                         glGetString (GL_SHADING_LANGUAGE_VERSION),
-                         max_texture_size);
-      gdk_debug_message ("Enabled features (use GDK_GL_DISABLE env var to disable):");
-      for (i = 0; i < G_N_ELEMENTS (gdk_gl_feature_keys); i++)
-        {
-          gdk_debug_message ("    %s: %s",
-                             gdk_gl_feature_keys[i].key,
-                             (priv->features & gdk_gl_feature_keys[i].value) ? "YES" :
-                             ((disabled_features & gdk_gl_feature_keys[i].value) ? "disabled via env var" :
-                             (((supported_features & gdk_gl_feature_keys[i].value) == 0) ? "not supported" :
-                             "Hum, what? This should not happen.")));
-        }
-    }
+  priv->has_half_float = gdk_gl_context_check_version (context, "3.0", "3.0") ||
+                         epoxy_has_gl_extension ("GL_OES_vertex_half_float");
+
+  priv->has_sync = gdk_gl_context_check_version (context, "3.2", "3.0") ||
+                   epoxy_has_gl_extension ("GL_ARB_sync") ||
+                   epoxy_has_gl_extension ("GL_APPLE_sync");
+
+  gdk_gl_context_init_memory_flags (context);
+
+  {
+    int max_texture_size;
+    glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_texture_size);
+    GDK_DISPLAY_DEBUG (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context)), OPENGL,
+                       "%s version: %d.%d (%s)\n"
+                       "* GLSL version: %s\n"
+                       "* Max texture size: %d\n"
+                       "* Extensions checked:\n"
+                       " - GL_KHR_debug: %s\n"
+                       " - GL_EXT_unpack_subimage: %s\n"
+                       " - half float: %s\n"
+                       " - sync: %s\n"
+                       " - bgra: %s",
+                       gdk_gl_context_get_use_es (context) ? "OpenGL ES" : "OpenGL",
+                       gdk_gl_version_get_major (&priv->gl_version), gdk_gl_version_get_minor (&priv->gl_version),
+                       priv->is_legacy ? "legacy" : "core",
+                       glGetString (GL_SHADING_LANGUAGE_VERSION),
+                       max_texture_size,
+                       priv->has_khr_debug ? "yes" : "no",
+                       priv->has_unpack_subimage ? "yes" : "no",
+                       priv->has_half_float ? "yes" : "no",
+                       priv->has_sync ? "yes" : "no",
+                       priv->has_bgra ? "yes" : "no");
+  }

  priv->extensions_checked = TRUE;
 }
@@ -2050,6 +2015,30 @@ gdk_gl_context_get_format_flags (GdkGLContext    *self,
  return priv->memory_flags[format];
 }

+gboolean
+gdk_gl_context_has_debug (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  return priv->debug_enabled || priv->use_khr_debug;
+}
+
+gboolean
+gdk_gl_context_has_vertex_half_float (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  return priv->has_half_float;
+}
+
+gboolean
+gdk_gl_context_has_sync (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  return priv->has_sync;
+}
+
 /* Return if glGenVertexArrays, glBindVertexArray and glDeleteVertexArrays
 * can be used
 */
@@ -27,15 +27,6 @@

 G_BEGIN_DECLS

-typedef enum {
-  GDK_GL_FEATURE_DEBUG                      = 1 << 0,
-  GDK_GL_FEATURE_UNPACK_SUBIMAGE            = 1 << 1,
-  GDK_GL_FEATURE_VERTEX_HALF_FLOAT          = 1 << 2,
-  GDK_GL_FEATURE_SYNC                       = 1 << 3,
-  GDK_GL_FEATURE_BASE_INSTANCE              = 1 << 4,
-  GDK_GL_FEATURE_BUFFER_STORAGE             = 1 << 5,
-} GdkGLFeatures;
-
 typedef enum {
  GDK_GL_NONE = 0,
  GDK_GL_EGL,
@@ -151,6 +142,7 @@ void                    gdk_gl_context_get_matching_version     (GdkGLContext
                                                                 gboolean                legacy,
                                                                 GdkGLVersion           *out_version);

+gboolean                gdk_gl_context_has_unpack_subimage      (GdkGLContext    *context);
 void                    gdk_gl_context_push_debug_group         (GdkGLContext    *context,
                                                                 const char      *message);
 void                    gdk_gl_context_push_debug_group_printf  (GdkGLContext    *context,
@@ -171,11 +163,14 @@ const char *            gdk_gl_context_get_glsl_version_string  (GdkGLContext

 GdkGLMemoryFlags        gdk_gl_context_get_format_flags         (GdkGLContext    *self,
                                                                 GdkMemoryFormat  format) G_GNUC_PURE;
-gboolean                gdk_gl_context_has_feature              (GdkGLContext    *self,
-                                                                 GdkGLFeatures    feature) G_GNUC_PURE;
+gboolean                gdk_gl_context_has_debug                (GdkGLContext    *self) G_GNUC_PURE;

 gboolean                gdk_gl_context_use_es_bgra              (GdkGLContext    *context);

+gboolean                gdk_gl_context_has_vertex_half_float    (GdkGLContext    *self) G_GNUC_PURE;
+
+gboolean                gdk_gl_context_has_sync                 (GdkGLContext    *self) G_GNUC_PURE;
+
 gboolean                gdk_gl_context_has_vertex_arrays        (GdkGLContext    *self) G_GNUC_PURE;

 double                  gdk_gl_context_get_scale                (GdkGLContext    *self);
@@ -494,7 +494,7 @@ gdk_gl_texture_new_from_builder (GdkGLTextureBuilder *builder,
  self->id = gdk_gl_texture_builder_get_id (builder);
  GDK_TEXTURE (self)->format = gdk_gl_texture_builder_get_format (builder);
  self->has_mipmap = gdk_gl_texture_builder_get_has_mipmap (builder);
-  if (gdk_gl_context_has_feature (self->context, GDK_GL_FEATURE_SYNC))
+  if (gdk_gl_context_has_sync (self->context))
    self->sync = gdk_gl_texture_builder_get_sync (builder);
  self->destroy = destroy;
  self->data = data;
@@ -260,11 +260,6 @@ gdk_vulkan_strerror (VkResult result)
    case VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT:
      return "The provided binary shader code is not compatible with this device. (VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT)";
 #endif
-#if VK_HEADER_VERSION >= 274
-    case VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR:
-      return "The specified Video Std parameters do not adhere to the syntactic or semantic requirements of the used video compression standard or implementation";
-#endif
-
    case VK_RESULT_MAX_ENUM:
    default:
      return "Unknown Vulkan error.";
@@ -552,8 +547,9 @@ physical_device_supports_extension (VkPhysicalDevice  device,
  return FALSE;
 }

-static GdkVulkanFeatures
-physical_device_check_features (VkPhysicalDevice device)
+static gboolean
+physical_device_check_features (VkPhysicalDevice   device,
+                                GdkVulkanFeatures *out_features)
 {
  VkPhysicalDeviceVulkan12Features v12_features = {
      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
@@ -562,16 +558,15 @@ physical_device_check_features (VkPhysicalDevice device)
      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
      .pNext = &v12_features
  };
-  VkPhysicalDeviceFeatures2 v10_features = {
+  VkPhysicalDeviceFeatures2 features = {
      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
      .pNext = &ycbcr_features
  };
  VkExternalSemaphoreProperties semaphore_props = {
      .sType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
  };
-  GdkVulkanFeatures features;

-  vkGetPhysicalDeviceFeatures2 (device, &v10_features);
+  vkGetPhysicalDeviceFeatures2 (device, &features);
  vkGetPhysicalDeviceExternalSemaphoreProperties (device,
                                                  &(VkPhysicalDeviceExternalSemaphoreInfo) {
 		                                      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
@@ -579,46 +574,46 @@ physical_device_check_features (VkPhysicalDevice device)
 	                                          },
                                                  &semaphore_props);

-  features = 0;
+  *out_features = 0;

-  if (v10_features.features.shaderUniformBufferArrayDynamicIndexing &&
-      v10_features.features.shaderSampledImageArrayDynamicIndexing)
-    features |= GDK_VULKAN_FEATURE_DYNAMIC_INDEXING;
+  if (features.features.shaderUniformBufferArrayDynamicIndexing &&
+      features.features.shaderSampledImageArrayDynamicIndexing)
+    *out_features |= GDK_VULKAN_FEATURE_DYNAMIC_INDEXING;

  if (v12_features.descriptorIndexing &&
      v12_features.descriptorBindingPartiallyBound &&
      v12_features.descriptorBindingVariableDescriptorCount &&
      v12_features.descriptorBindingSampledImageUpdateAfterBind &&
      v12_features.descriptorBindingStorageBufferUpdateAfterBind)
-    features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING;
+    *out_features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING;
  else if (physical_device_supports_extension (device, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME))
-    features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING;
+    *out_features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING;

  if (v12_features.shaderSampledImageArrayNonUniformIndexing &&
      v12_features.shaderStorageBufferArrayNonUniformIndexing)
-    features |= GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING;
+    *out_features |= GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING;

  if (ycbcr_features.samplerYcbcrConversion ||
      physical_device_supports_extension (device, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME))
-    features |= GDK_VULKAN_FEATURE_YCBCR;
+    *out_features |= GDK_VULKAN_FEATURE_YCBCR;

  if (physical_device_supports_extension (device, VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME) &&
      physical_device_supports_extension (device, VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME))
-    features |= GDK_VULKAN_FEATURE_DMABUF;
+    *out_features |= GDK_VULKAN_FEATURE_DMABUF;

  if (physical_device_supports_extension (device, VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME))
    {
      if (semaphore_props.externalSemaphoreFeatures & VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT)
-        features |= GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT;
+        *out_features |= GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT;

      if (semaphore_props.externalSemaphoreFeatures & VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT)
-        features |= GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT;
+        *out_features |= GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT;
    }

  if (physical_device_supports_extension (device, VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME))
-    features |= GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT;
+    *out_features |= GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT;

-  return features;
+  return TRUE;
 }

 static void
@@ -1366,7 +1361,7 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
  first = 0;
  last = n_devices;

-  skip_features = gdk_parse_debug_var ("GDK_VULKAN_DISABLE",
+  skip_features = gdk_parse_debug_var ("GDK_VULKAN_SKIP",
                                       gsk_vulkan_feature_keys,
                                       G_N_ELEMENTS (gsk_vulkan_feature_keys));

@@ -1454,7 +1449,8 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
      GdkVulkanFeatures features, device_features;
      uint32_t n_queue_props;

-      device_features = physical_device_check_features (devices[i]);
+      if (!physical_device_check_features (devices[i], &device_features))
+        continue;

      features = device_features & ~skip_features;

@@ -1539,7 +1535,7 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
              display->vk_queue_family_index = j;
              display->vulkan_features = features;

-              GDK_DISPLAY_DEBUG (display, VULKAN, "Enabled features (use GDK_VULKAN_DISABLE env var to disable):");
+              GDK_DISPLAY_DEBUG (display, VULKAN, "Enabled features (use GDK_VULKAN_SKIP env var to disable):");
              for (i = 0; i < G_N_ELEMENTS (gsk_vulkan_feature_keys); i++)
                {
                  GDK_DISPLAY_DEBUG (display, VULKAN, "    %s: %s",
@@ -30,7 +30,6 @@
 #include <jpeglib.h>
 #include <jerror.h>
 #include <setjmp.h>
-#include <malloc.h>

 /* {{{ Error handling */

@@ -238,10 +237,8 @@ gdk_load_jpeg (GBytes  *input_bytes,

  g_bytes_unref (bytes);

-  malloc_trim (0);
-
  gdk_profiler_end_mark (before, "Load jpeg", NULL);
-
+ 
  return texture;
 }

@@ -27,7 +27,6 @@
 #include "gsk/gl/fp16private.h"
 #include <png.h>
 #include <stdio.h>
-#include <malloc.h>

 /* The main difference between the png load/save code here and
 * gdk-pixbuf is that we can support loading 16-bit data in the
@@ -301,8 +300,6 @@ gdk_load_png (GBytes  *bytes,
  g_free (row_pointers);
  png_destroy_read_struct (&png, &info, NULL);

-  malloc_trim (0);
-
  if (GDK_PROFILER_IS_RUNNING)
    {
      gint64 end = GDK_PROFILER_CURRENT_TIME;
@@ -26,7 +26,6 @@
 #include "gdktexturedownloaderprivate.h"

 #include <tiffio.h>
-#include <malloc.h>

 /* Our main interest in tiff as an image format is that it is
 * flexible enough to save all our texture formats without
@@ -501,8 +500,6 @@ gdk_load_tiff (GBytes  *input_bytes,

  TIFFClose (tif);

-  malloc_trim (0);
-
  if (GDK_PROFILER_IS_RUNNING)
    {
      gint64 end = GDK_PROFILER_CURRENT_TIME;
@@ -214,6 +214,22 @@ typedef NSString *CALayerContentsGravity;
    }
 }

+-(void)setFrame:(NSRect)frame display:(BOOL)display
+{
+  NSRect contentRect = [self contentRectForFrameRect:frame];
+  GdkSurface *surface = GDK_SURFACE (gdk_surface);
+  gboolean maximized = (surface->state & GDK_TOPLEVEL_STATE_MAXIMIZED) != 0;
+
+  if (maximized && !inMaximizeTransition && !NSEqualRects (lastMaximizedFrame, frame))
+    {
+      gdk_synthesize_surface_state (surface, GDK_TOPLEVEL_STATE_MAXIMIZED, 0);
+      _gdk_surface_update_size (surface);
+    }
+
+  [super setFrame:frame display:display];
+  [[self contentView] setFrame:NSMakeRect (0, 0, contentRect.size.width, contentRect.size.height)];
+}
+
 -(id)initWithContentRect:(NSRect)contentRect
               styleMask:(NSWindowStyleMask)styleMask
                 backing:(NSBackingStoreType)backingType
@@ -296,6 +312,10 @@ typedef NSString *CALayerContentsGravity;
  GdkMonitor *monitor;
  GdkRectangle geometry;
  GdkRectangle workarea;
+  int shadow_top = 0;
+  int shadow_left = 0;
+  int shadow_right = 0;
+  int shadow_bottom = 0;
  GdkRectangle window_gdk;
  GdkPoint pointer_position;
  GdkPoint new_origin;
@@ -303,6 +323,13 @@ typedef NSString *CALayerContentsGravity;
  if (!inManualMove)
    return NO;

+  /* Get our shadow so we can adjust the window position sans-shadow */
+  _gdk_macos_surface_get_shadow (gdk_surface,
+                                 &shadow_top,
+                                 &shadow_right,
+                                 &shadow_bottom,
+                                 &shadow_left);
+
  windowFrame = [self frame];
  currentLocation = [NSEvent mouseLocation];

@@ -328,9 +355,21 @@ typedef NSString *CALayerContentsGravity;
  window_gdk.width = windowFrame.size.width;
  window_gdk.height = windowFrame.size.height;

+  /* Subtract our shadowin from the window */
+  window_gdk.x += shadow_left;
+  window_gdk.y += shadow_top;
+  window_gdk.width = window_gdk.width - shadow_left - shadow_right;
+  window_gdk.height = window_gdk.height - shadow_top - shadow_bottom;
+
  /* Now place things on the monitor */
  _edge_snapping_motion (&self->snapping, &pointer_position, &window_gdk);

+  /* And add our shadow back to the frame */
+  window_gdk.x -= shadow_left;
+  window_gdk.y -= shadow_top;
+  window_gdk.width += shadow_left + shadow_right;
+  window_gdk.height += shadow_top + shadow_bottom;
+
  /* Convert to quartz coordinates */
  _gdk_macos_display_to_display_coords ([self gdkDisplay],
                                        window_gdk.x,
@@ -348,17 +387,12 @@ typedef NSString *CALayerContentsGravity;

 -(void)windowDidMove:(NSNotification *)notification
 {
-  if ([self isZoomed])
-    gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_TOPLEVEL_STATE_MAXIMIZED);
-  else
-    gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), GDK_TOPLEVEL_STATE_MAXIMIZED, 0);
-
  _gdk_macos_surface_configure ([self gdkSurface]);
 }

 -(void)windowDidResize:(NSNotification *)notification
 {
-  [self windowDidMove: notification];
+  _gdk_macos_surface_configure (gdk_surface);

  /* If we're using server-side decorations, this notification is coming
   * in from a display-side change. We need to request a layout in
@@ -379,6 +413,7 @@ typedef NSString *CALayerContentsGravity;

 -(void)beginManualMove
 {
+  gboolean maximized = GDK_SURFACE (gdk_surface)->state & GDK_TOPLEVEL_STATE_MAXIMIZED;
  NSPoint initialMoveLocation;
  GdkPoint point;
  GdkMonitor *monitor;
@@ -397,6 +432,13 @@ typedef NSString *CALayerContentsGravity;

  initialMoveLocation = [NSEvent mouseLocation];

+  if (maximized)
+    [self setFrame:NSMakeRect (initialMoveLocation.x - (int)lastUnmaximizedFrame.size.width/2,
+                               initialMoveLocation.y,
+                               lastUnmaximizedFrame.size.width,
+                               lastUnmaximizedFrame.size.height)
+           display:YES];
+
  _gdk_macos_display_from_display_coords ([self gdkDisplay],
                                          initialMoveLocation.x,
                                          initialMoveLocation.y,
@@ -692,16 +734,26 @@ typedef NSString *CALayerContentsGravity;

 -(void)setStyleMask:(NSWindowStyleMask)styleMask
 {
+  gboolean was_fullscreen;
+  gboolean is_fullscreen;
  gboolean was_opaque;
  gboolean is_opaque;

+  was_fullscreen = (([self styleMask] & NSWindowStyleMaskFullScreen) != 0);
  was_opaque = (([self styleMask] & NSWindowStyleMaskTitled) != 0);

  [super setStyleMask:styleMask];

+  is_fullscreen = (([self styleMask] & NSWindowStyleMaskFullScreen) != 0);
  is_opaque = (([self styleMask] & NSWindowStyleMaskTitled) != 0);

-  _gdk_macos_surface_update_fullscreen_state (gdk_surface);
+  if (was_fullscreen != is_fullscreen)
+    {
+      if (was_fullscreen)
+        [self setFrame:lastUnfullscreenFrame display:NO];
+
+      _gdk_macos_surface_update_fullscreen_state (gdk_surface);
+    }

  if (was_opaque != is_opaque)
    {
@@ -714,20 +766,58 @@ typedef NSString *CALayerContentsGravity;

 -(NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen *)screen
 {
+  GdkMacosSurface *surface = gdk_surface;
  NSRect rect;
+  int shadow_top;

+  /* Allow the window to move up "shadow_top" more than normally allowed
+   * by the default impl. This makes it possible to move windows with
+   * client side shadow right up to the screen's menu bar. */
+  _gdk_macos_surface_get_shadow (surface, &shadow_top, NULL, NULL, NULL);
  rect = [super constrainFrameRect:frameRect toScreen:screen];
  if (frameRect.origin.y > rect.origin.y)
-    rect.origin.y = MIN (frameRect.origin.y, rect.origin.y);
+    rect.origin.y = MIN (frameRect.origin.y, rect.origin.y + shadow_top);

  return rect;
 }

-/* Implementing this method avoids new windows move around the screen. */
 -(NSRect)windowWillUseStandardFrame:(NSWindow *)nsWindow
                       defaultFrame:(NSRect)newFrame
 {
-  return newFrame;
+  NSRect screenFrame = [[self screen] visibleFrame];
+  GdkMacosSurface *surface = gdk_surface;
+  gboolean maximized = GDK_SURFACE (surface)->state & GDK_TOPLEVEL_STATE_MAXIMIZED;
+
+  if (!maximized)
+    return screenFrame;
+  else
+    return lastUnmaximizedFrame;
+}
+
+-(BOOL)windowShouldZoom:(NSWindow *)nsWindow
+                toFrame:(NSRect)newFrame
+{
+  GdkMacosSurface *surface = gdk_surface;
+  GdkToplevelState state = GDK_SURFACE (surface)->state;
+
+  if (state & GDK_TOPLEVEL_STATE_MAXIMIZED)
+    {
+      lastMaximizedFrame = newFrame;
+    }
+  else
+    {
+      lastUnmaximizedFrame = [nsWindow frame];
+      gdk_synthesize_surface_state (GDK_SURFACE (gdk_surface), 0, GDK_TOPLEVEL_STATE_MAXIMIZED);
+    }
+
+  inMaximizeTransition = YES;
+
+  return YES;
+}
+
+-(void)windowDidEndLiveResize:(NSNotification *)aNotification
+{
+  inMaximizeTransition = NO;
 }

 -(NSSize)window:(NSWindow *)window willUseFullScreenContentSize:(NSSize)proposedSize
@@ -738,6 +828,7 @@ typedef NSString *CALayerContentsGravity;
 -(void)windowWillEnterFullScreen:(NSNotification *)aNotification
 {
  inFullscreenTransition = YES;
+  lastUnfullscreenFrame = [self frame];
 }

 -(void)windowDidEnterFullScreen:(NSNotification *)aNotification
@@ -49,6 +49,10 @@

  EdgeSnapping     snapping;

+  NSRect           lastUnmaximizedFrame;
+  NSRect           lastMaximizedFrame;
+  NSRect           lastUnfullscreenFrame;
+  BOOL             inMaximizeTransition;
  BOOL             inFullscreenTransition;
 }

@@ -151,57 +151,6 @@ create_blank_cursor (void)
  return nscursor;
 }

-static NSCursor *
-create_cursor_from_texture (GdkTexture *texture,
-                            int         x,
-                            int         y)
-{
-  guint32 width;
-  guint32 height;
-  guchar *pixels;
-  gsize stride;
-  GdkTextureDownloader *downloader;
-  NSCursor *nscursor;
-  NSBitmapImageRep *nsbitmap;
-  NSImage *nsimage;
-
-  if (texture == NULL)
-    return create_blank_cursor ();
-
-  width = gdk_texture_get_width (texture);
-  height = gdk_texture_get_height (texture);
-
-  nsbitmap = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
-                                       pixelsWide:width
-                                       pixelsHigh:height
-                                       bitsPerSample:8
-                                       samplesPerPixel:4
-                                       hasAlpha:YES
-                                       isPlanar:NO
-                                       colorSpaceName:NSDeviceRGBColorSpace
-                                       bytesPerRow:0
-                                       bitsPerPixel:0];
-  pixels = [nsbitmap bitmapData];
-  stride = [nsbitmap bytesPerRow];
-
-  downloader = gdk_texture_downloader_new (texture);
-  gdk_texture_downloader_set_format (downloader, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED);
-  gdk_texture_downloader_download_into (downloader,
-                                        pixels,
-                                        stride);
-  gdk_texture_downloader_free (downloader);
-
-  nsimage = [[NSImage alloc] init];
-  [nsimage addRepresentation:nsbitmap];
-  [nsimage setSize:NSMakeSize(width, height)];
-  [nsbitmap release];
-
-  nscursor = [[NSCursor alloc] initWithImage:nsimage
-                               hotSpot:NSMakePoint(x, y)];
-  [nsimage release];
-  return nscursor;
-}
-
 NSCursor *
 _gdk_macos_cursor_get_ns_cursor (GdkCursor *cursor)
 {
@@ -212,17 +161,7 @@ _gdk_macos_cursor_get_ns_cursor (GdkCursor *cursor)
  g_return_val_if_fail (!cursor || GDK_IS_CURSOR (cursor), NULL);

  if (cursor != NULL)
-    {
-      name = gdk_cursor_get_name (cursor);
-
-      if (name == NULL)
-        {
-          nscursor = create_cursor_from_texture (gdk_cursor_get_texture (cursor),
-                                                 gdk_cursor_get_hotspot_x (cursor),
-                                                 gdk_cursor_get_hotspot_y (cursor));
-          return nscursor;
-        }
-    }
+    name = gdk_cursor_get_name (cursor);

  if (name == NULL)
    goto load_cursor;
@@ -47,20 +47,20 @@ _gdk_macos_display_position_toplevel_with_parent (GdkMacosDisplay *self,
  /* Try to center on top of the parent but also try to make the whole thing
   * visible in case that lands us under the topbar/panel/etc.
   */
-  parent_rect.x = parent->root_x;
-  parent_rect.y = parent->root_y;
-  parent_rect.width = GDK_SURFACE (parent)->width;
-  parent_rect.height = GDK_SURFACE (parent)->height;
+  parent_rect.x = parent->root_x + parent->shadow_left;
+  parent_rect.y = parent->root_y + parent->shadow_top;
+  parent_rect.width = GDK_SURFACE (parent)->width - parent->shadow_left - parent->shadow_right;
+  parent_rect.height = GDK_SURFACE (parent)->height - parent->shadow_top - parent->shadow_bottom;

-  surface_rect.width = GDK_SURFACE (surface)->width;
-  surface_rect.height = GDK_SURFACE (surface)->height;
+  surface_rect.width = GDK_SURFACE (surface)->width - surface->shadow_left - surface->shadow_right;
+  surface_rect.height = GDK_SURFACE (surface)->height - surface->shadow_top - surface->shadow_bottom;
  surface_rect.x = parent_rect.x + ((parent_rect.width - surface_rect.width) / 2);
  surface_rect.y = parent_rect.y + ((parent_rect.height - surface_rect.height) / 2);

  _gdk_macos_monitor_clamp (GDK_MACOS_MONITOR (monitor), &surface_rect);

-  *x = surface_rect.x;
-  *y = surface_rect.y;
+  *x = surface_rect.x - surface->shadow_left;
+  *y = surface_rect.y - surface->shadow_top;
 }

 static inline gboolean
@@ -99,15 +99,15 @@ _gdk_macos_display_position_toplevel (GdkMacosDisplay *self,
  gdk_macos_monitor_get_workarea (monitor, &workarea);

  /* First place at top-left of current monitor */
-  surface_rect.width = GDK_SURFACE (surface)->width;
-  surface_rect.height = GDK_SURFACE (surface)->height;
+  surface_rect.width = GDK_SURFACE (surface)->width - surface->shadow_left - surface->shadow_right;
+  surface_rect.height = GDK_SURFACE (surface)->height - surface->shadow_top - surface->shadow_bottom;
  surface_rect.x = workarea.x + ((workarea.width - surface_rect.width) / 2);
  surface_rect.y = workarea.y + ((workarea.height - surface_rect.height) / 2);

  _gdk_macos_monitor_clamp (GDK_MACOS_MONITOR (surface->best_monitor), &surface_rect);

-  *x = surface_rect.x;
-  *y = surface_rect.y;
+  *x = surface_rect.x - surface->shadow_left;
+  *y = surface_rect.y - surface->shadow_top;

  /* Try to see if there are any other surfaces at this origin and if so,
   * adjust until we get something better.
@@ -119,11 +119,11 @@ _gdk_macos_display_position_toplevel (GdkMacosDisplay *self,
      *y += WARP_OFFSET_Y;

      /* If we reached the bottom right, just bail and try the workspace origin */
-      if (*x + WARP_OFFSET_X > workarea.x + workarea.width ||
-          *y + WARP_OFFSET_Y > workarea.y + workarea.height)
+      if (*x + surface->shadow_left + WARP_OFFSET_X > workarea.x + workarea.width ||
+          *y + surface->shadow_top + WARP_OFFSET_Y > workarea.y + workarea.height)
        {
-          *x = workarea.x;
-          *y = workarea.y;
+          *x = workarea.x - surface->shadow_left;
+          *y = workarea.y - surface->shadow_top;
          return;
        }
    }
@@ -998,9 +998,7 @@ _gdk_macos_display_get_nsevent (GdkEvent *event)
    {
      const GdkToNSEventMap *map = iter->data;

-      if (map->gdk_event->event_type == event->event_type &&
-          map->gdk_event->device == event->device &&
-          map->gdk_event->time == event->time)
+      if (map->gdk_event == event)
        return map->nsevent;
    }

@@ -68,10 +68,19 @@ gdk_macos_popup_surface_layout (GdkMacosPopupSurface *self,
    monitor = _gdk_macos_surface_get_best_monitor (GDK_MACOS_SURFACE (self));
  gdk_macos_monitor_get_workarea (monitor, &bounds);

+  gdk_popup_layout_get_shadow_width (layout,
+                                     &self->parent_instance.shadow_left,
+                                     &self->parent_instance.shadow_right,
+                                     &self->parent_instance.shadow_top,
+                                     &self->parent_instance.shadow_bottom);
+
  gdk_surface_layout_popup_helper (GDK_SURFACE (self),
                                   width,
                                   height,
-                                   0, 0, 0, 0, /* shadow-left/right/top/bottom */
+                                   self->parent_instance.shadow_left,
+                                   self->parent_instance.shadow_right,
+                                   self->parent_instance.shadow_top,
+                                   self->parent_instance.shadow_bottom,
                                   monitor,
                                   &bounds,
                                   self->layout,
@@ -61,6 +61,11 @@ struct _GdkMacosSurface
    int height;
  } next_layout;

+  int shadow_top;
+  int shadow_right;
+  int shadow_bottom;
+  int shadow_left;
+
  cairo_rectangle_int_t next_frame;

  gint64 pending_frame_counter;
@@ -86,6 +91,16 @@ CGDirectDisplayID  _gdk_macos_surface_get_screen_id           (GdkMacosSurface
 const char        *_gdk_macos_surface_get_title               (GdkMacosSurface      *self);
 void               _gdk_macos_surface_set_title               (GdkMacosSurface      *self,
                                                               const char           *title);
+void               _gdk_macos_surface_get_shadow              (GdkMacosSurface      *self,
+                                                               int                  *top,
+                                                               int                  *right,
+                                                               int                  *bottom,
+                                                               int                  *left);
+void               _gdk_macos_surface_set_shadow              (GdkMacosSurface      *self,
+                                                               int                   top,
+                                                               int                   right,
+                                                               int                   bottom,
+                                                               int                   left);
 gboolean           _gdk_macos_surface_is_opaque               (GdkMacosSurface      *self);
 NSView            *_gdk_macos_surface_get_view                (GdkMacosSurface      *self);
 gboolean           _gdk_macos_surface_get_modal_hint          (GdkMacosSurface      *self);
@@ -56,6 +56,14 @@ enum {

 static GParamSpec *properties [LAST_PROP];

+static gboolean
+window_is_fullscreen (GdkMacosSurface *self)
+{
+  g_assert (GDK_IS_MACOS_SURFACE (self));
+
+  return ([self->window styleMask] & NSWindowStyleMaskFullScreen) != 0;
+}
+
 void
 _gdk_macos_surface_request_frame (GdkMacosSurface *self)
 {
@@ -236,6 +244,32 @@ gdk_macos_surface_get_scale (GdkSurface *surface)
  return [self->window backingScaleFactor];
 }

+void
+_gdk_macos_surface_set_shadow (GdkMacosSurface *surface,
+                               int              top,
+                               int              right,
+                               int              bottom,
+                               int              left)
+{
+  GdkMacosSurface *self = (GdkMacosSurface *)surface;
+
+  g_assert (GDK_IS_MACOS_SURFACE (self));
+
+  if (self->shadow_top == top &&
+      self->shadow_right == right &&
+      self->shadow_bottom == bottom &&
+      self->shadow_left == left)
+    return;
+
+  self->shadow_top = top;
+  self->shadow_right = right;
+  self->shadow_bottom = bottom;
+  self->shadow_left = left;
+
+  if (top || right || bottom || left)
+    [self->window setHasShadow:NO];
+}
+
 static void
 gdk_macos_surface_begin_frame (GdkMacosSurface *self)
 {
@@ -553,6 +587,29 @@ gdk_macos_surface_init (GdkMacosSurface *self)
  self->monitors = g_ptr_array_new_with_free_func (g_object_unref);
 }

+void
+_gdk_macos_surface_get_shadow (GdkMacosSurface *self,
+                               int             *top,
+                               int             *right,
+                               int             *bottom,
+                               int             *left)
+{
+
+  g_return_if_fail (GDK_IS_MACOS_SURFACE (self));
+
+  if (top)
+    *top = self->shadow_top;
+
+  if (left)
+    *left = self->shadow_left;
+
+  if (bottom)
+    *bottom = self->shadow_bottom;
+
+  if (right)
+    *right = self->shadow_right;
+}
+
 gboolean
 _gdk_macos_surface_is_opaque (GdkMacosSurface *self)
 {
@@ -701,7 +758,7 @@ _gdk_macos_surface_update_fullscreen_state (GdkMacosSurface *self)
  g_return_if_fail (GDK_IS_MACOS_SURFACE (self));

  state = GDK_SURFACE (self)->state;
-  is_fullscreen = ([self->window styleMask] & NSWindowStyleMaskFullScreen) != 0;
+  is_fullscreen = window_is_fullscreen (self);
  was_fullscreen = (state & GDK_TOPLEVEL_STATE_FULLSCREEN) != 0;

  if (is_fullscreen != was_fullscreen)
@@ -1048,12 +1105,16 @@ _gdk_macos_surface_monitor_changed (GdkMacosSurface *self)

          g_set_object (&child->best_monitor, best);

-          area.x = self->root_x + GDK_SURFACE (child)->x;
-          area.y = self->root_y + GDK_SURFACE (child)->y;
-          area.width = GDK_SURFACE (child)->width;
-          area.height = GDK_SURFACE (child)->height;
+          area.x = self->root_x + GDK_SURFACE (child)->x + child->shadow_left;
+          area.y = self->root_y + GDK_SURFACE (child)->y + child->shadow_top;
+          area.width = GDK_SURFACE (child)->width - child->shadow_left - child->shadow_right;
+          area.height = GDK_SURFACE (child)->height - child->shadow_top - child->shadow_bottom;

          _gdk_macos_monitor_clamp (GDK_MACOS_MONITOR (best), &area);
+
+          area.x -= child->shadow_left;
+          area.y -= child->shadow_top;
+
          _gdk_macos_surface_move (child, area.x, area.y);
          gdk_surface_invalidate_rect (GDK_SURFACE (child), NULL);
        }
@@ -96,26 +96,37 @@ _gdk_macos_toplevel_surface_unminimize (GdkMacosToplevelSurface *self)
    [window deminiaturize:window];
 }

-static gboolean
-_gdk_macos_toplevel_surface_compute_size (GdkSurface *surface)
+static void
+_gdk_macos_toplevel_surface_present (GdkToplevel       *toplevel,
+                                     GdkToplevelLayout *layout)
 {
-  GdkMacosToplevelSurface *self = (GdkMacosToplevelSurface *)surface;
-  GdkMacosSurface *macos_surface = (GdkMacosSurface *)surface;
-  GdkToplevelSize size;
-  GdkDisplay *display;
+  GdkSurface *surface = GDK_SURFACE (toplevel);
+  GdkMacosToplevelSurface *self = (GdkMacosToplevelSurface *)toplevel;
+  NSWindow *nswindow = _gdk_macos_surface_get_native (GDK_MACOS_SURFACE (self));
+  GdkDisplay *display = gdk_surface_get_display (surface);
  GdkMonitor *monitor;
+  GdkToplevelSize size;
  int bounds_width, bounds_height;
+  int width, height;
  GdkGeometry geometry;
  GdkSurfaceHints mask;
+  NSWindowStyleMask style_mask;
+  gboolean maximize;
+  gboolean fullscreen;

  g_assert (GDK_IS_MACOS_TOPLEVEL_SURFACE (self));
+  g_assert (GDK_IS_MACOS_WINDOW (nswindow));

-  if (!GDK_MACOS_SURFACE (surface)->geometry_dirty)
-    return FALSE;
+  if (layout != self->layout)
+    {
+      g_clear_pointer (&self->layout, gdk_toplevel_layout_unref);
+      self->layout = gdk_toplevel_layout_copy (layout);
+    }

-  GDK_MACOS_SURFACE (surface)->geometry_dirty = FALSE;
+  _gdk_macos_toplevel_surface_attach_to_parent (self);
+
+  style_mask = [nswindow styleMask];

-  display = gdk_surface_get_display (surface);
  monitor = gdk_display_get_monitor_at_surface (display, surface);

  if (monitor)
@@ -133,121 +144,59 @@ _gdk_macos_toplevel_surface_compute_size (GdkSurface *surface)
    }

  gdk_toplevel_size_init (&size, bounds_width, bounds_height);
-  gdk_toplevel_notify_compute_size (GDK_TOPLEVEL (surface), &size);
-
+  gdk_toplevel_notify_compute_size (toplevel, &size);
  g_warn_if_fail (size.width > 0);
  g_warn_if_fail (size.height > 0);
+  width = size.width;
+  height = size.height;

-  if (self->layout != NULL &&
-      gdk_toplevel_layout_get_resizable (self->layout))
+  if (gdk_toplevel_layout_get_resizable (layout))
    {
      geometry.min_width = size.min_width;
      geometry.min_height = size.min_height;
      mask = GDK_HINT_MIN_SIZE;
+
+      /* Only set 'Resizable' mask to get native resize zones if the window is
+       * titled, otherwise we do this internally for CSD and do not need
+       * NSWindow to do it for us. Additionally, it can mess things up when
+       * doing a window resize since it can cause mouseDown to get passed
+       * through to the next window.
+       */
+      if ((style_mask & NSWindowStyleMaskTitled) != 0)
+        style_mask |= NSWindowStyleMaskResizable;
+      else
+        style_mask &= ~NSWindowStyleMaskResizable;
    }
  else
    {
-      geometry.max_width = geometry.min_width = size.width;
-      geometry.max_height = geometry.min_height = size.height;
+      geometry.max_width = geometry.min_width = width;
+      geometry.max_height = geometry.min_height = height;
      mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
+
+      style_mask &= ~NSWindowStyleMaskResizable;
    }

-  _gdk_macos_surface_set_geometry_hints (macos_surface, &geometry, mask);
-
-  if (surface->state & (GDK_TOPLEVEL_STATE_FULLSCREEN |
-                        GDK_TOPLEVEL_STATE_MAXIMIZED |
-                        GDK_TOPLEVEL_STATE_TILED |
-                        GDK_TOPLEVEL_STATE_TOP_TILED |
-                        GDK_TOPLEVEL_STATE_RIGHT_TILED |
-                        GDK_TOPLEVEL_STATE_BOTTOM_TILED |
-                        GDK_TOPLEVEL_STATE_LEFT_TILED |
-                        GDK_TOPLEVEL_STATE_MINIMIZED) ||
-      [macos_surface->window inLiveResize])
-    return FALSE;
-
-  /* If we delayed a user resize until the beginning of the frame,
-   * apply it now so we can start processing updates for it.
-   */
-  if (macos_surface->next_layout.width > 0 &&
-      macos_surface->next_layout.height > 0)
-    {
-      int root_x = macos_surface->next_layout.root_x;
-      int root_y = macos_surface->next_layout.root_y;
-      int width = macos_surface->next_layout.width;
-      int height = macos_surface->next_layout.height;
-
-      gdk_surface_constrain_size (&geometry, mask,
-                                  width, height,
-                                  &width, &height);
-
-      macos_surface->next_layout.width = 0;
-      macos_surface->next_layout.height = 0;
-
-      _gdk_macos_surface_move_resize (macos_surface,
-                                      root_x, root_y,
-                                      width, height);
-
-      return FALSE;
-    }
-
-  gdk_surface_constrain_size (&geometry, mask,
-                              size.width, size.height,
-                              &size.width, &size.height);
-
-  if ((size.width != self->last_computed_width ||
-       size.height != self->last_computed_height) &&
-      (size.width != surface->width ||
-       size.height != surface->height))
-    {
-      self->last_computed_width = size.width;
-      self->last_computed_height = size.height;
-
-      _gdk_macos_surface_resize (macos_surface, size.width, size.height);
-    }
-
-  return FALSE;
-}
-
-static void
-_gdk_macos_toplevel_surface_present (GdkToplevel       *toplevel,
-                                     GdkToplevelLayout *layout)
-{
-  GdkSurface *surface = GDK_SURFACE (toplevel);
-  GdkMacosToplevelSurface *self = (GdkMacosToplevelSurface *)toplevel;
-  NSWindow *nswindow = _gdk_macos_surface_get_native (GDK_MACOS_SURFACE (self));
-  GdkDisplay *display = gdk_surface_get_display (surface);
-  NSWindowStyleMask style_mask;
-  gboolean maximize;
-  gboolean fullscreen;
-
-  g_assert (GDK_IS_MACOS_TOPLEVEL_SURFACE (self));
-  g_assert (GDK_IS_MACOS_WINDOW (nswindow));
-
-  if (layout != self->layout)
-    {
-      g_clear_pointer (&self->layout, gdk_toplevel_layout_unref);
-      self->layout = gdk_toplevel_layout_copy (layout);
-    }
-
-  _gdk_macos_toplevel_surface_attach_to_parent (self);
-  _gdk_macos_toplevel_surface_compute_size (surface);
-
-  /* Only set 'Resizable' mask to get native resize zones if the window is
-   * titled, otherwise we do this internally for CSD and do not need
-   * NSWindow to do it for us. Additionally, it can mess things up when
-   * doing a window resize since it can cause mouseDown to get passed
-   * through to the next window.
-   */
-  style_mask = [nswindow styleMask];
-  if (gdk_toplevel_layout_get_resizable (layout) &&
-      (style_mask & NSWindowStyleMaskTitled) != 0)
-    style_mask |= NSWindowStyleMaskResizable;
-  else
-    style_mask &= ~NSWindowStyleMaskResizable;
-
  if (style_mask != [nswindow styleMask])
    [nswindow setStyleMask:style_mask];

+  if (size.shadow.is_valid)
+    _gdk_macos_surface_set_shadow (GDK_MACOS_SURFACE (surface),
+                                   size.shadow.top,
+                                   size.shadow.right,
+                                   size.shadow.bottom,
+                                   size.shadow.left);
+
+  _gdk_macos_surface_set_geometry_hints (GDK_MACOS_SURFACE (self), &geometry, mask);
+  gdk_surface_constrain_size (&geometry, mask, width, height, &width, &height);
+
+  GDK_DEBUG (MISC, "Resizing \"%s\" to %dx%d",
+                   GDK_MACOS_SURFACE (self)->title ?
+                   GDK_MACOS_SURFACE (self)->title :
+                   "untitled",
+                   width, height);
+
+  _gdk_macos_surface_resize (GDK_MACOS_SURFACE (self), width, height);
+
  /* Maximized state */
  if (gdk_toplevel_layout_get_maximized (layout, &maximize))
    {
@@ -429,6 +378,125 @@ _gdk_macos_toplevel_surface_hide (GdkSurface *surface)
  GDK_SURFACE_CLASS (_gdk_macos_toplevel_surface_parent_class)->hide (surface);
 }

+static gboolean
+_gdk_macos_toplevel_surface_compute_size (GdkSurface *surface)
+{
+  GdkMacosToplevelSurface *self = (GdkMacosToplevelSurface *)surface;
+  GdkMacosSurface *macos_surface = (GdkMacosSurface *)surface;
+  GdkToplevelSize size;
+  GdkDisplay *display;
+  GdkMonitor *monitor;
+  int bounds_width, bounds_height;
+  GdkGeometry geometry;
+  GdkSurfaceHints mask;
+
+  g_assert (GDK_IS_MACOS_TOPLEVEL_SURFACE (self));
+
+  if (!GDK_MACOS_SURFACE (surface)->geometry_dirty)
+    return FALSE;
+
+  GDK_MACOS_SURFACE (surface)->geometry_dirty = FALSE;
+
+  display = gdk_surface_get_display (surface);
+  monitor = gdk_display_get_monitor_at_surface (display, surface);
+
+  if (monitor)
+    {
+      GdkRectangle workarea;
+
+      gdk_macos_monitor_get_workarea (monitor, &workarea);
+      bounds_width = workarea.width;
+      bounds_height = workarea.height;
+    }
+  else
+    {
+      bounds_width = G_MAXINT;
+      bounds_height = G_MAXINT;
+    }
+
+  gdk_toplevel_size_init (&size, bounds_width, bounds_height);
+  gdk_toplevel_notify_compute_size (GDK_TOPLEVEL (surface), &size);
+
+  g_warn_if_fail (size.width > 0);
+  g_warn_if_fail (size.height > 0);
+
+  if (self->layout != NULL &&
+      gdk_toplevel_layout_get_resizable (self->layout))
+    {
+      geometry.min_width = size.min_width;
+      geometry.min_height = size.min_height;
+      mask = GDK_HINT_MIN_SIZE;
+    }
+  else
+    {
+      geometry.max_width = geometry.min_width = size.width;
+      geometry.max_height = geometry.min_height = size.height;
+      mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
+    }
+
+  if (size.shadow.is_valid)
+    _gdk_macos_surface_set_shadow (macos_surface,
+                                   size.shadow.top,
+                                   size.shadow.right,
+                                   size.shadow.bottom,
+                                   size.shadow.left);
+
+  _gdk_macos_surface_set_geometry_hints (macos_surface, &geometry, mask);
+
+  if (surface->state & (GDK_TOPLEVEL_STATE_FULLSCREEN |
+                        GDK_TOPLEVEL_STATE_MAXIMIZED |
+                        GDK_TOPLEVEL_STATE_TILED |
+                        GDK_TOPLEVEL_STATE_TOP_TILED |
+                        GDK_TOPLEVEL_STATE_RIGHT_TILED |
+                        GDK_TOPLEVEL_STATE_BOTTOM_TILED |
+                        GDK_TOPLEVEL_STATE_LEFT_TILED |
+                        GDK_TOPLEVEL_STATE_MINIMIZED) ||
+      [macos_surface->window inLiveResize])
+    return FALSE;
+
+  /* If we delayed a user resize until the beginning of the frame,
+   * apply it now so we can start processing updates for it.
+   */
+  if (macos_surface->next_layout.width > 0 &&
+      macos_surface->next_layout.height > 0)
+    {
+      int root_x = macos_surface->next_layout.root_x;
+      int root_y = macos_surface->next_layout.root_y;
+      int width = macos_surface->next_layout.width;
+      int height = macos_surface->next_layout.height;
+
+      gdk_surface_constrain_size (&geometry, mask,
+                                  width, height,
+                                  &width, &height);
+
+      macos_surface->next_layout.width = 0;
+      macos_surface->next_layout.height = 0;
+
+      _gdk_macos_surface_move_resize (macos_surface,
+                                      root_x, root_y,
+                                      width, height);
+
+      return FALSE;
+    }
+
+  gdk_surface_constrain_size (&geometry, mask,
+                              size.width, size.height,
+                              &size.width, &size.height);
+
+  if ((size.width != self->last_computed_width ||
+       size.height != self->last_computed_height) &&
+      (size.width != surface->width ||
+       size.height != surface->height))
+    {
+      self->last_computed_width = size.width;
+      self->last_computed_height = size.height;
+
+      _gdk_macos_surface_resize (macos_surface, size.width, size.height);
+    }
+
+  return FALSE;
+}
+
 static void
 _gdk_macos_toplevel_surface_request_layout (GdkSurface *surface)
 {
@@ -79,7 +79,6 @@ static const struct {
  { "move",         "dnd-move" },
  { "no-drop",      "dnd-none" },
  { "dnd-ask",      "dnd-copy" }, /* not CSS, but we want to guarantee it anyway */
-  { "dnd-move",     "default" },
  { "not-allowed",  "crossed_circle" },
  { "grab",         "hand2" },
  { "grabbing",     "hand2" },
@@ -310,8 +310,7 @@ gdk_wayland_device_update_surface_cursor (GdkDevice *device)
  if (buffer)
    {
      wl_surface_attach (pointer->pointer_surface, buffer, 0, 0);
-      if (wl_surface_get_version (pointer->pointer_surface) >= WL_SURFACE_SET_BUFFER_SCALE_SINCE_VERSION)
-        wl_surface_set_buffer_scale (pointer->pointer_surface, scale);
+      wl_surface_set_buffer_scale (pointer->pointer_surface, scale);
      wl_surface_damage (pointer->pointer_surface,  0, 0, w, h);
      wl_surface_commit (pointer->pointer_surface);
    }
@@ -58,7 +58,6 @@
 #include <wayland/xdg-foreign-unstable-v2-client-protocol.h>
 #include <wayland/server-decoration-client-protocol.h>
 #include "linux-dmabuf-unstable-v1-client-protocol.h"
-#include "presentation-time-client-protocol.h"

 #include "wm-button-layout-translation.h"

@@ -96,6 +95,7 @@
 #define GTK_SHELL1_VERSION       5
 #define OUTPUT_VERSION_WITH_DONE 2
 #define NO_XDG_OUTPUT_DONE_SINCE_VERSION 3
+#define XDG_ACTIVATION_VERSION   1
 #define OUTPUT_VERSION           3

 #ifdef HAVE_TOPLEVEL_STATE_SUSPENDED
@@ -585,25 +585,21 @@ gdk_registry_handle_global (void               *data,
    {
      display_wayland->xdg_activation =
        wl_registry_bind (display_wayland->wl_registry, id,
-                          &xdg_activation_v1_interface, 1);
+                          &xdg_activation_v1_interface,
+                          MIN (version, XDG_ACTIVATION_VERSION));
    }
  else if (strcmp (interface, "wp_fractional_scale_manager_v1") == 0)
    {
      display_wayland->fractional_scale =
        wl_registry_bind (display_wayland->wl_registry, id,
-                          &wp_fractional_scale_manager_v1_interface, 1);
+                          &wp_fractional_scale_manager_v1_interface,
+                          MIN (version, 1));
    }
  else if (strcmp (interface, "wp_viewporter") == 0)
    {
      display_wayland->viewporter =
        wl_registry_bind (display_wayland->wl_registry, id,
-                          &wp_viewporter_interface, 1);
-    }
-  else if (strcmp (interface, "wp_presentation") == 0)
-    {
-      display_wayland->presentation =
-        wl_registry_bind (display_wayland->wl_registry, id,
-                          &wp_presentation_interface,
+                          &wp_viewporter_interface,
                          MIN (version, 1));
    }

@@ -704,8 +700,7 @@ _gdk_wayland_display_open (const char *display_name)
  process_on_globals_closures (display_wayland);

  /* Wait for initializing to complete. This means waiting for all
-   * asynchronous roundtrips that were triggered during initial roundtrip.
-   */
+   * asynchronous roundtrips that were triggered during initial roundtrip. */
  while (display_wayland->async_roundtrips != NULL)
    {
      if (wl_display_dispatch (display_wayland->wl_display) < 0)
@@ -715,18 +710,6 @@ _gdk_wayland_display_open (const char *display_name)
        }
    }

-  /* Check that we got all the required globals */
-  if (display_wayland->compositor == NULL ||
-      display_wayland->shm == NULL ||
-      display_wayland->data_device_manager == NULL)
-    {
-      g_warning ("The Wayland compositor does not provide one or more of the required interfaces, "
-                 "not using Wayland display");
-      g_object_unref (display);
-
-      return NULL;
-    }
-
  if (display_wayland->xdg_wm_base_id)
    {
      display_wayland->shell_variant = GDK_WAYLAND_SHELL_VARIANT_XDG_SHELL;
@@ -816,7 +799,6 @@ gdk_wayland_display_dispose (GObject *object)
  g_clear_pointer (&display_wayland->xdg_activation, xdg_activation_v1_destroy);
  g_clear_pointer (&display_wayland->fractional_scale, wp_fractional_scale_manager_v1_destroy);
  g_clear_pointer (&display_wayland->viewporter, wp_viewporter_destroy);
-  g_clear_pointer (&display_wayland->presentation, wp_presentation_destroy);
  g_clear_pointer (&display_wayland->linux_dmabuf, zwp_linux_dmabuf_v1_destroy);
  g_clear_pointer (&display_wayland->linux_dmabuf_feedback, zwp_linux_dmabuf_feedback_v1_destroy);
  if (display_wayland->linux_dmabuf_formats)
@@ -39,7 +39,6 @@
 #include <gdk/wayland/xdg-activation-v1-client-protocol.h>
 #include <gdk/wayland/fractional-scale-v1-client-protocol.h>
 #include <gdk/wayland/viewporter-client-protocol.h>
-#include <gdk/wayland/presentation-time-client-protocol.h>

 #include <glib.h>
 #include <gdk/gdkkeys.h>
@@ -126,7 +125,6 @@ struct _GdkWaylandDisplay
  struct xdg_activation_v1 *xdg_activation;
  struct wp_fractional_scale_manager_v1 *fractional_scale;
  struct wp_viewporter *viewporter;
-  struct wp_presentation *presentation;

  GList *async_roundtrips;

@@ -34,7 +34,6 @@
 #include <gdk/wayland/gdkwayland.h>
 #include <gdk/wayland/gdkdisplay-wayland.h>
 #include <gdk/wayland/gdkseat-wayland.h>
-#include <gdk/wayland/gdkwaylandpresentationtime-private.h>

 #include <xkbcommon/xkbcommon.h>

@@ -466,9 +466,9 @@ gdk_wayland_surface_create_subsurface (GdkSurface *surface)
  GdkWaylandSubsurface *sub;
  struct wl_region *region;

-  if (disp->subcompositor == NULL || disp->viewporter == NULL)
+  if (disp->viewporter == NULL)
    {
-      GDK_DISPLAY_DEBUG (display, OFFLOAD, "Can't use subsurfaces without subcompositor and viewporter");
+      GDK_DISPLAY_DEBUG (display, OFFLOAD, "Can't use subsurfaces without viewporter");
      return NULL;
    }

@@ -44,8 +44,6 @@ struct _GdkWaylandSurface
  struct wl_event_queue *event_queue;
  struct wl_callback *frame_callback;

-  GdkWaylandPresentationTime *presentation_time;
-
  unsigned int initial_configure_received : 1;
  unsigned int has_uncommitted_ack_configure : 1;
  unsigned int has_pending_subsurface_commits : 1;
@@ -52,7 +52,6 @@
 #include "gdktoplevel-wayland-private.h"

 #include "linux-dmabuf-unstable-v1-client-protocol.h"
-#include "presentation-time-client-protocol.h"


 /**
@@ -202,23 +201,17 @@ get_egl_window_size (GdkSurface *surface,

  if (GDK_DISPLAY_DEBUG_CHECK (display, GL_NO_FRACTIONAL))
    {
+      GDK_DISPLAY_DEBUG (display, OPENGL, "Using integer scale %d for EGL window", gdk_fractional_scale_to_int (&impl->scale));
+
      *width = surface->width * gdk_fractional_scale_to_int (&impl->scale);
      *height = surface->height * gdk_fractional_scale_to_int (&impl->scale);
-
-      GDK_DISPLAY_DEBUG (display, OPENGL, "Using integer scale %d for EGL window (%d %d => %d %d)",
-                         gdk_fractional_scale_to_int (&impl->scale),
-                         surface->width, surface->height,
-                         *width, *height);
    }
  else
    {
+      GDK_DISPLAY_DEBUG (display, OPENGL, "Using fractional scale %g for EGL window", gdk_fractional_scale_to_double (&impl->scale));
+
      *width = gdk_fractional_scale_scale (&impl->scale, surface->width),
      *height = gdk_fractional_scale_scale (&impl->scale, surface->height);
-
-      GDK_DISPLAY_DEBUG (display, OPENGL, "Using fractional scale %g for EGL window (%d %d => %d %d)",
-                         gdk_fractional_scale_to_double (&impl->scale),
-                         surface->width, surface->height,
-                         *width, *height);
    }
 }

@@ -404,17 +397,6 @@ gdk_wayland_surface_request_frame (GdkSurface *surface)
  wl_proxy_set_queue ((struct wl_proxy *) self->frame_callback, NULL);
  wl_callback_add_listener (self->frame_callback, &frame_listener, surface);

-  if (self->presentation_time == NULL)
-    {
-      GdkWaylandDisplay *wayland_display = GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
-      self->presentation_time = gdk_wayland_presentation_time_new (wayland_display);
-    }
-
-  gdk_wayland_presentation_time_track (self->presentation_time,
-                                       clock,
-                                       self->display_server.wl_surface,
-                                       gdk_frame_clock_get_frame_counter (clock));
-
  for (gsize i = 0; i < gdk_surface_get_n_subsurfaces (surface); i++)
    {
      GdkSubsurface *subsurface = gdk_surface_get_subsurface (surface, i);
@@ -1060,7 +1042,6 @@ gdk_wayland_surface_hide_surface (GdkSurface *surface)

  unmap_popups_for_surface (surface);

-  g_clear_pointer (&impl->presentation_time, gdk_wayland_presentation_time_free);
  g_clear_pointer (&impl->frame_callback, wl_callback_destroy);
  if (impl->awaiting_frame_frozen)
    {
@@ -34,7 +34,6 @@
 #include "gdktoplevelprivate.h"
 #include "gdkdevice-wayland-private.h"

-#include <wayland/presentation-time-client-protocol.h>
 #include <wayland/xdg-shell-unstable-v6-client-protocol.h>
 #include <wayland/xdg-foreign-unstable-v2-client-protocol.h>

@@ -123,8 +122,6 @@ struct _GdkWaylandToplevel

  struct wl_output *initial_fullscreen_output;

-  struct wp_presentation_feedback *feedback;
-
  struct {
    GdkToplevelState unset_flags;
    GdkToplevelState set_flags;
@@ -461,49 +458,6 @@ gdk_wayland_toplevel_compute_size (GdkSurface *surface)
  return FALSE;
 }

-static gboolean
-has_per_edge_tiling_info (GdkToplevelState state)
-{
-  return state & (GDK_TOPLEVEL_STATE_TOP_TILED |
-                  GDK_TOPLEVEL_STATE_RIGHT_TILED |
-                  GDK_TOPLEVEL_STATE_BOTTOM_TILED |
-                  GDK_TOPLEVEL_STATE_LEFT_TILED);
-}
-
-static GdkToplevelState
-infer_edge_constraints (GdkToplevelState state)
-{
-  if (state & (GDK_TOPLEVEL_STATE_MAXIMIZED | GDK_TOPLEVEL_STATE_FULLSCREEN))
-    return state;
-
-  if (!(state & GDK_TOPLEVEL_STATE_TILED) || !has_per_edge_tiling_info (state))
-    return state |
-           GDK_TOPLEVEL_STATE_TOP_RESIZABLE |
-           GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE |
-           GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE |
-           GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;
-
-  if (!(state & GDK_TOPLEVEL_STATE_TOP_TILED))
-    state |= GDK_TOPLEVEL_STATE_TOP_RESIZABLE;
-  if (!(state & GDK_TOPLEVEL_STATE_RIGHT_TILED))
-    state |= GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE;
-  if (!(state & GDK_TOPLEVEL_STATE_BOTTOM_TILED))
-    state |= GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;
-  if (!(state & GDK_TOPLEVEL_STATE_LEFT_TILED))
-    state |= GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;
-
-  return state;
-}
-
-static gboolean
-supports_native_edge_constraints (GdkWaylandToplevel*toplevel)
-{
-  struct gtk_surface1 *gtk_surface = toplevel->display_server.gtk_surface;
-  if (!gtk_surface)
-    return FALSE;
-  return gtk_surface1_get_version (gtk_surface) >= GTK_SURFACE1_CONFIGURE_EDGES_SINCE_VERSION;
-}
-
 static void
 gdk_wayland_toplevel_handle_configure (GdkWaylandSurface *wayland_surface)
 {
@@ -521,9 +475,6 @@ gdk_wayland_toplevel_handle_configure (GdkWaylandSurface *wayland_surface)
  new_state = wayland_toplevel->pending.state;
  wayland_toplevel->pending.state = 0;

-  if (!supports_native_edge_constraints (wayland_toplevel))
-    new_state = infer_edge_constraints (new_state);
-
  is_resizing = wayland_toplevel->pending.is_resizing;
  wayland_toplevel->pending.is_resizing = FALSE;

@@ -2039,7 +1990,13 @@ gdk_wayland_toplevel_titlebar_gesture (GdkToplevel        *toplevel,
 static gboolean
 gdk_wayland_toplevel_supports_edge_constraints (GdkToplevel *toplevel)
 {
-  return TRUE;
+  GdkWaylandToplevel *wayland_toplevel = GDK_WAYLAND_TOPLEVEL (toplevel);
+  struct gtk_surface1 *gtk_surface = wayland_toplevel->display_server.gtk_surface;
+
+  if (!gtk_surface)
+    return FALSE;
+
+  return gtk_surface1_get_version (gtk_surface) >= GTK_SURFACE1_CONFIGURE_EDGES_SINCE_VERSION;
 }

 static void
@@ -2710,7 +2667,7 @@ gdk_wayland_toplevel_set_transient_for_exported (GdkToplevel *toplevel,
  g_return_val_if_fail (GDK_IS_WAYLAND_TOPLEVEL (toplevel), FALSE);
  g_return_val_if_fail (GDK_IS_WAYLAND_DISPLAY (display), FALSE);

-  if (!display_wayland->xdg_importer && !display_wayland->xdg_importer_v2)
+  if (!display_wayland->xdg_importer)
    {
      g_warning ("Server is missing xdg_foreign support");
      return FALSE;
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <gdk/gdkframeclock.h>
-#include <gdk/wayland/gdkdisplay-wayland.h>
-#include <gdk/wayland/gdksurface-wayland.h>
-#include <gdk/wayland/gdkwaylanddisplay.h>
-
-G_BEGIN_DECLS
-
-typedef struct _GdkWaylandPresentationTime GdkWaylandPresentationTime;
-
-GdkWaylandPresentationTime *gdk_wayland_presentation_time_new   (GdkWaylandDisplay          *display);
-void                        gdk_wayland_presentation_time_track (GdkWaylandPresentationTime *self,
-                                                                 GdkFrameClock              *frame_clock,
-                                                                 struct wl_surface          *surface,
-                                                                 gint64                      frame_number);
-void                        gdk_wayland_presentation_time_free  (GdkWaylandPresentationTime *self);
-
-G_END_DECLS
@@ -1,152 +0,0 @@
-#include "config.h"
-
-#include <gdk/gdkframeclockprivate.h>
-
-#include "gdkwaylandpresentationtime-private.h"
-
-typedef struct _GdkWaylandPresentationFrame
-{
-  GdkWaylandPresentationTime *self;
-  struct wp_presentation_feedback *feedback;
-  GdkFrameClock *frame_clock;
-  gint64 frame_number;
-} GdkWaylandPresentationFrame;
-
-static void
-gdk_wayland_presentation_frame_free (GdkWaylandPresentationFrame *frame)
-{
-  g_clear_pointer (&frame->feedback, wp_presentation_feedback_destroy);
-  g_clear_object (&frame->frame_clock);
-  frame->self = NULL;
-  g_free (frame);
-}
-
-struct _GdkWaylandPresentationTime
-{
-  GdkWaylandDisplay *display;
-  GPtrArray *frames;
-};
-
-GdkWaylandPresentationTime *
-gdk_wayland_presentation_time_new (GdkWaylandDisplay *display)
-{
-  GdkWaylandPresentationTime *self;
-
-  g_return_val_if_fail (GDK_IS_WAYLAND_DISPLAY (display), NULL);
-
-  self = g_new0 (GdkWaylandPresentationTime, 1);
-  self->display = g_object_ref (display);
-  self->frames = g_ptr_array_new_with_free_func ((GDestroyNotify)gdk_wayland_presentation_frame_free);
-
-  return self;
-}
-
-void
-gdk_wayland_presentation_time_free (GdkWaylandPresentationTime *self)
-{
-  g_clear_pointer (&self->frames, g_ptr_array_unref);
-  g_clear_object (&self->display);
-  g_free (self);
-}
-
-static gint64
-time_from_wayland (uint32_t tv_sec_hi,
-                   uint32_t tv_sec_lo,
-                   uint32_t tv_nsec)
-{
-  guint64 t = tv_sec_hi;
-  t <<= 32;
-  t |= tv_sec_lo;
-  t *= G_USEC_PER_SEC;
-  t += tv_nsec / 1000L;
-  return (gint64)t;
-}
-
-static void
-gdk_wayland_presentation_feedback_sync_output (void                            *data,
-                                               struct wp_presentation_feedback *feedback,
-                                               struct wl_output                *output)
-{
-}
-
-static void
-gdk_wayland_presentation_feedback_presented (void                            *data,
-                                             struct wp_presentation_feedback *feedback,
-                                             uint32_t                         tv_sec_hi,
-                                             uint32_t                         tv_sec_lo,
-                                             uint32_t                         tv_nsec,
-                                             uint32_t                         refresh,
-                                             uint32_t                         seq_hi,
-                                             uint32_t                         seq_lo,
-                                             uint32_t                         flags)
-{
-  GdkWaylandPresentationFrame *frame = data;
-  GdkWaylandPresentationTime *self;
-  GdkFrameTimings *timings;
-  guint pos;
-
-  g_assert (frame != NULL);
-  g_assert (frame->self != NULL);
-
-  self = frame->self;
-
-  if ((timings = gdk_frame_clock_get_timings (frame->frame_clock, frame->frame_number)))
-    {
-      timings->presentation_time = time_from_wayland (tv_sec_hi, tv_sec_lo, tv_nsec);
-      timings->complete = TRUE;
-    }
-
-  if (g_ptr_array_find (self->frames, frame, &pos))
-    g_ptr_array_remove_index_fast (self->frames, pos);
-}
-
-static void
-gdk_wayland_presentation_feedback_discarded (void                            *data,
-                                             struct wp_presentation_feedback *feedback)
-{
-  GdkWaylandPresentationFrame *frame = data;
-  guint pos;
-
-  g_assert (frame != NULL);
-  g_assert (frame->self != NULL);
-
-  if (g_ptr_array_find (frame->self->frames, frame, &pos))
-    g_ptr_array_remove_index_fast (frame->self->frames, pos);
-}
-
-static const struct wp_presentation_feedback_listener gdk_wayland_presentation_feedback_listener = {
-  gdk_wayland_presentation_feedback_sync_output,
-  gdk_wayland_presentation_feedback_presented,
-  gdk_wayland_presentation_feedback_discarded,
-};
-
-void
-gdk_wayland_presentation_time_track (GdkWaylandPresentationTime *self,
-                                     GdkFrameClock              *frame_clock,
-                                     struct wl_surface          *surface,
-                                     gint64                      frame_number)
-{
-  struct wp_presentation_feedback *feedback;
-  GdkWaylandPresentationFrame *frame;
-
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (surface != NULL);
-
-  if (self->display->presentation == NULL)
-    return;
-
-  if (!(feedback = wp_presentation_feedback (self->display->presentation, surface)))
-    return;
-
-  frame = g_new0 (GdkWaylandPresentationFrame, 1);
-  frame->self = self;
-  frame->frame_clock = g_object_ref (frame_clock);
-  frame->frame_number = frame_number;
-  frame->feedback = g_steal_pointer (&feedback);
-
-  g_ptr_array_add (self->frames, frame);
-
-  wp_presentation_feedback_add_listener (frame->feedback,
-                                         &gdk_wayland_presentation_feedback_listener,
-                                         frame);
-}
@@ -22,7 +22,6 @@ gdk_wayland_sources = files([
  'gdktoplevel-wayland.c',
  'gdkpopup-wayland.c',
  'gdkvulkancontext-wayland.c',
-  'gdkwaylandpresentationtime.c',
  'wm-button-layout-translation.c',
 ])

@@ -70,7 +69,6 @@ proto_sources = [
  ['xdg-activation', 'staging', 'v1', ],
  ['fractional-scale', 'staging', 'v1', ],
  ['linux-dmabuf', 'unstable', 'v1', ],
-  ['presentation-time', 'stable', 'v1', ],
 ]

 gdk_wayland_gen_headers = []
@@ -1627,7 +1627,7 @@ _gdk_win32_surface_lacks_wm_decorations (GdkSurface *window)
  has_any_decorations = FALSE;

  if (style & (WS_BORDER | WS_THICKFRAME | WS_CAPTION |
-               WS_SYSMENU | WS_MAXIMIZEBOX))
+               WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX))
    has_any_decorations = TRUE;
  else
    GDK_NOTE (MISC, g_print ("Window %p (handle %p): has no decorations (style %lx)\n",
@@ -1696,6 +1696,7 @@ _gdk_win32_surface_update_style_bits (GdkSurface *window)
      update_single_bit (&new_style, all, decorations & GDK_DECOR_RESIZEH, WS_THICKFRAME);
      update_single_bit (&new_style, all, decorations & GDK_DECOR_TITLE, WS_CAPTION);
      update_single_bit (&new_style, all, decorations & GDK_DECOR_MENU, WS_SYSMENU);
+      update_single_bit (&new_style, all, decorations & GDK_DECOR_MINIMIZE, WS_MINIMIZEBOX);
      update_single_bit (&new_style, all, decorations & GDK_DECOR_MAXIMIZE, WS_MAXIMIZEBOX);
    }

@@ -3015,8 +3015,6 @@ gdk_x11_display_init_gl_backend (GdkX11Display  *self,

  self->egl_version = epoxy_egl_version (egl_display);

-  XFree (visinfo);
-
  return TRUE;
 }

@@ -488,14 +488,12 @@ gsk_gl_command_queue_new (GdkGLContext      *context,
      int max_texture_size = atoi (g_getenv ("GSK_MAX_TEXTURE_SIZE"));
      if (max_texture_size == 0)
        {
-          g_warning ("Failed to parse %s", "GSK_MAX_TEXTURE_SIZE");
+          g_warning ("Failed to parse GSK_MAX_TEXTURE_SIZE");
        }
      else
        {
          max_texture_size = MAX (max_texture_size, 512);
-          GSK_DEBUG (RENDERER,
-                     "Limiting texture size in the GL renderer to %d (via %s)",
-                     max_texture_size, "GSK_MAX_TEXTURE_SIZE");
+          GSK_DEBUG(OPENGL, "Limiting max texture size to %d", max_texture_size);
          self->max_texture_size = MIN (self->max_texture_size, max_texture_size);
        }
    }
@@ -1624,7 +1622,7 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
    {
      glTexSubImage2D (GL_TEXTURE_2D, 0, x, y, width, height, gl_format, gl_type, data);
    }
-  else if (stride % bpp == 0 && gdk_gl_context_has_feature (self->context, GDK_GL_FEATURE_UNPACK_SUBIMAGE))
+  else if (stride % bpp == 0 && gdk_gl_context_has_unpack_subimage (self->context))
    {
      glPixelStorei (GL_UNPACK_ROW_LENGTH, stride / bpp);

@@ -1835,7 +1835,7 @@ gsk_gl_driver_create_gdk_texture (GskGLDriver     *self,
  state = g_new0 (GskGLTextureState, 1);
  state->texture_id = texture_id;
  state->context = g_object_ref (self->command_queue->context);
-  if (gdk_gl_context_has_feature (self->command_queue->context, GDK_GL_FEATURE_SYNC))
+  if (gdk_gl_context_has_sync (self->command_queue->context))
    state->sync = glFenceSync (GL_SYNC_GPU_COMMANDS_COMPLETE, 0);

  g_hash_table_steal (self->textures, GUINT_TO_POINTER (texture_id));
@@ -194,7 +194,7 @@ gsk_gl_renderer_realize (GskRenderer  *renderer,
    {
      gdk_gl_context_make_current (context);

-      if (!gdk_gl_context_has_feature (context, GDK_GL_FEATURE_VERTEX_HALF_FLOAT))
+      if (!gdk_gl_context_has_vertex_half_float (context))
        {
          int major, minor;

@@ -52,6 +52,8 @@
 #include "ninesliceprivate.h"
 #include "fp16private.h"

+#define ALLOW_OFFLOAD_FOR_ANY_TEXTURE 1
+
 #define ORTHO_NEAR_PLANE   -10000
 #define ORTHO_FAR_PLANE     10000
 #define MAX_GRADIENT_STOPS  6
@@ -174,8 +176,6 @@ struct _GskGLRenderJob
   * looking at the format of the framebuffer we are rendering on.
   */
  int target_format;
-
-  guint offscreen_count; /* if > 0, we're rendering to an offscreen */
 };

 typedef struct _GskGLRenderOffscreen
@@ -1235,7 +1235,7 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob      *job,
  texture = gdk_texture_new_for_surface (surface);
  texture_id = gsk_gl_driver_load_texture (job->driver, texture, FALSE);

-  if (gdk_gl_context_has_feature (job->command_queue->context, GDK_GL_FEATURE_DEBUG))
+  if (gdk_gl_context_has_debug (job->command_queue->context))
    gdk_gl_context_label_object_printf (job->command_queue->context, GL_TEXTURE, texture_id,
                                        "Fallback %s %d",
                                        g_type_name_from_instance ((GTypeInstance *) node),
@@ -2532,7 +2532,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
                                          get_target_format (job, node),
                                          &render_target);

-      if (gdk_gl_context_has_feature (context, GDK_GL_FEATURE_DEBUG))
+      if (gdk_gl_context_has_debug (context))
        {
          gdk_gl_context_label_object_printf (context,
                                              GL_TEXTURE,
@@ -4002,15 +4002,9 @@ gsk_gl_render_job_visit_subsurface_node (GskGLRenderJob      *job,
    {
      if (!gdk_subsurface_is_above_parent (subsurface))
        {
-          if (job->offscreen_count > 0)
+          /* Clear the area so we can see through */
+          if (gsk_gl_render_job_begin_draw (job, CHOOSE_PROGRAM (job, color)))
            {
-              GDK_DISPLAY_DEBUG (gdk_gl_context_get_display (job->command_queue->context), OFFLOAD, "Hiding subsurface %p in offscreen context", subsurface);
-              gdk_subsurface_detach (subsurface);
-              gsk_gl_render_job_visit_node (job, gsk_subsurface_node_get_child (node));
-            }
-          else if (gsk_gl_render_job_begin_draw (job, CHOOSE_PROGRAM (job, color)))
-            {
-              /* Clear the area so we can see through */
              GskGLCommandBatch *batch;
              guint16 color[4];
              rgba_to_half (&(GdkRGBA){0,0,0,0}, color);
@@ -4388,7 +4382,7 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob       *job,
                                           &render_target))
    g_assert_not_reached ();

-  if (gdk_gl_context_has_feature (job->command_queue->context, GDK_GL_FEATURE_DEBUG))
+  if (gdk_gl_context_has_debug (job->command_queue->context))
    {
      gdk_gl_context_label_object_printf (job->command_queue->context,
                                          GL_TEXTURE,
@@ -4428,12 +4422,8 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob       *job,
      reset_clip = TRUE;
    }

-  job->offscreen_count++;
-
  gsk_gl_render_job_visit_node (job, node);

-  job->offscreen_count--;
-
  if (reset_clip)
    gsk_gl_render_job_pop_clip (job);

@@ -2,14 +2,13 @@

 #include "gskglbufferprivate.h"

-/* {{{ GskGLBuffer */
-
 struct _GskGLBuffer
 {
  GskGpuBuffer parent_instance;

  GLenum target;
  GLuint buffer_id;
+  GLenum access;
  guchar *data;
 };

@@ -20,6 +19,7 @@ gsk_gl_buffer_finalize (GObject *object)
 {
  GskGLBuffer *self = GSK_GL_BUFFER (object);

+  g_free (self->data);
  glDeleteBuffers (1, &self->buffer_id);

  G_OBJECT_CLASS (gsk_gl_buffer_parent_class)->finalize (object);
@@ -34,9 +34,13 @@ gsk_gl_buffer_map (GskGpuBuffer *buffer)
 }

 static void
-gsk_gl_buffer_unmap (GskGpuBuffer *buffer,
-                     gsize         used)
+gsk_gl_buffer_unmap (GskGpuBuffer *buffer)
 {
+  GskGLBuffer *self = GSK_GL_BUFFER (buffer);
+
+  gsk_gl_buffer_bind (self);
+
+  glBufferSubData (self->target, 0, gsk_gpu_buffer_get_size (buffer), self->data);
 }

 static void
@@ -56,6 +60,28 @@ gsk_gl_buffer_init (GskGLBuffer *self)
 {
 }

+GskGpuBuffer *
+gsk_gl_buffer_new (GLenum target,
+                   gsize  size,
+                   GLenum access)
+{
+  GskGLBuffer *self;
+
+  self = g_object_new (GSK_TYPE_GL_BUFFER, NULL);
+
+  gsk_gpu_buffer_setup (GSK_GPU_BUFFER (self), size);
+
+  self->target = target;
+  self->access = access;
+
+  glGenBuffers (1, &self->buffer_id);
+  glBindBuffer (target, self->buffer_id);
+  glBufferData (target, size, NULL, GL_STATIC_DRAW);
+  self->data = malloc (size);
+
+  return GSK_GPU_BUFFER (self);
+}
+
 void
 gsk_gl_buffer_bind (GskGLBuffer *self)
 {
@@ -69,140 +95,3 @@ gsk_gl_buffer_bind_base (GskGLBuffer *self,
  glBindBufferBase (self->target, index, self->buffer_id);
 }

-static void
-gsk_gl_buffer_setup (GskGLBuffer *self,
-                     GLenum       target,
-                     gsize        size)
-{
-  gsk_gpu_buffer_setup (GSK_GPU_BUFFER (self), size);
-
-  self->target = target;
-
-  glGenBuffers (1, &self->buffer_id);
-}
-
-/* }}} */
-/* {{{ GskGLMappedBuffer */
-
-struct _GskGLMappedBuffer
-{
-  GskGLBuffer parent_instance;
-};
-
-G_DEFINE_TYPE (GskGLMappedBuffer, gsk_gl_mapped_buffer, GSK_TYPE_GL_BUFFER)
-
-static void
-gsk_gl_mapped_buffer_finalize (GObject *object)
-{
-  GskGLBuffer *self = GSK_GL_BUFFER (object);
-
-  gsk_gl_buffer_bind (self);
-  glUnmapBuffer (self->target);
-
-  G_OBJECT_CLASS (gsk_gl_mapped_buffer_parent_class)->finalize (object);
-}
-
-static void
-gsk_gl_mapped_buffer_class_init (GskGLMappedBufferClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-
-  gobject_class->finalize = gsk_gl_mapped_buffer_finalize;
-}
-
-static void
-gsk_gl_mapped_buffer_init (GskGLMappedBuffer *self)
-{
-}
-
-GskGpuBuffer *
-gsk_gl_mapped_buffer_new (GLenum target,
-                          gsize  size)
-{
-  GskGLBuffer *self;
-
-  self = g_object_new (GSK_TYPE_GL_MAPPED_BUFFER, NULL);
-
-  gsk_gl_buffer_setup (self, target, size);
-  gsk_gl_buffer_bind (self);
-
-  glBufferStorage (target,
-                   size,
-                   NULL,
-                   GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-  self->data = glMapBufferRange (target,
-                                 0,
-                                 size,
-                                 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-
-  return GSK_GPU_BUFFER (self);
-}
-
-/* }}} */
-/* {{{ GskGLCopiedBuffer */
-
-struct _GskGLCopiedBuffer
-{
-  GskGLBuffer parent_instance;
-};
-
-G_DEFINE_TYPE (GskGLCopiedBuffer, gsk_gl_copied_buffer, GSK_TYPE_GL_BUFFER)
-
-static void
-gsk_gl_copied_buffer_finalize (GObject *object)
-{
-  GskGLBuffer *self = GSK_GL_BUFFER (object);
-
-  g_free (self->data);
-
-  G_OBJECT_CLASS (gsk_gl_copied_buffer_parent_class)->finalize (object);
-}
-
-static void
-gsk_gl_copied_buffer_unmap (GskGpuBuffer *buffer,
-                            gsize         used)
-{
-  GskGLBuffer *self = GSK_GL_BUFFER (buffer);
-
-  if (used == 0)
-    return;
-
-  gsk_gl_buffer_bind (self);
-
-  glBufferSubData (self->target, 0, used, self->data);
-}
-
-static void
-gsk_gl_copied_buffer_class_init (GskGLCopiedBufferClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-  GskGpuBufferClass *buffer_class = GSK_GPU_BUFFER_CLASS (klass);
-
-  gobject_class->finalize = gsk_gl_copied_buffer_finalize;
-
-  buffer_class->unmap = gsk_gl_copied_buffer_unmap;
-}
-
-static void
-gsk_gl_copied_buffer_init (GskGLCopiedBuffer *self)
-{
-}
-
-GskGpuBuffer *
-gsk_gl_copied_buffer_new (GLenum target,
-                          gsize  size)
-{
-  GskGLBuffer *self;
-
-  self = g_object_new (GSK_TYPE_GL_COPIED_BUFFER, NULL);
-
-  gsk_gl_buffer_setup (self, target, size);
-  gsk_gl_buffer_bind (self);
-
-  glBufferData (target, size, NULL, GL_STATIC_DRAW);
-  self->data = malloc (size);
-
-  return GSK_GPU_BUFFER (self);
-}
-
-/* }}} */
@@ -7,17 +7,12 @@
 G_BEGIN_DECLS

 #define GSK_TYPE_GL_BUFFER (gsk_gl_buffer_get_type ())
-#define GSK_TYPE_GL_MAPPED_BUFFER (gsk_gl_mapped_buffer_get_type ())
-#define GSK_TYPE_GL_COPIED_BUFFER (gsk_gl_copied_buffer_get_type ())

 G_DECLARE_FINAL_TYPE (GskGLBuffer, gsk_gl_buffer, GSK, GL_BUFFER, GskGpuBuffer)
-G_DECLARE_FINAL_TYPE (GskGLMappedBuffer, gsk_gl_mapped_buffer, GSK, GL_MAPPED_BUFFER, GskGLBuffer)
-G_DECLARE_FINAL_TYPE (GskGLCopiedBuffer, gsk_gl_copied_buffer, GSK, GL_COPIED_BUFFER, GskGLBuffer)

-GskGpuBuffer *          gsk_gl_mapped_buffer_new                        (GLenum                  target,
-                                                                         gsize                   size);
-GskGpuBuffer *          gsk_gl_copied_buffer_new                        (GLenum                  target,
-                                                                         gsize                   size);
+GskGpuBuffer *          gsk_gl_buffer_new                               (GLenum                  target,
+                                                                         gsize                   size,
+                                                                         GLenum                  access);

 void                    gsk_gl_buffer_bind                              (GskGLBuffer            *self);
 void                    gsk_gl_buffer_bind_base                         (GskGLBuffer            *self,
@@ -9,7 +9,6 @@

 #include "gdk/gdkdisplayprivate.h"
 #include "gdk/gdkglcontextprivate.h"
-#include "gdk/gdkprofilerprivate.h"

 #include <glib/gi18n-lib.h>

@@ -474,7 +473,6 @@ gsk_gl_device_load_program (GskGLDevice               *self,
                            guint                      n_external_textures,
                            GError                   **error)
 {
-  G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
  GLuint vertex_shader_id, fragment_shader_id, program_id;
  GLint link_status;

@@ -529,11 +527,6 @@ gsk_gl_device_load_program (GskGLDevice               *self,
      return 0;
    }

-  gdk_profiler_end_markf (begin_time,
-                          "Compile Program",
-                          "name=%s id=%u frag=%u vert=%u",
-                          op_class->shader_name, program_id, fragment_shader_id, vertex_shader_id);
-
  return program_id;
 }

@@ -20,7 +20,6 @@ struct _GskGLFrame

  GLuint globals_buffer_id;
  guint next_texture_slot;
-  GLsync sync;

  GHashTable *vaos;
 };
@@ -35,23 +34,7 @@ G_DEFINE_TYPE (GskGLFrame, gsk_gl_frame, GSK_TYPE_GPU_FRAME)
 static gboolean
 gsk_gl_frame_is_busy (GskGpuFrame *frame)
 {
-  GskGLFrame *self = GSK_GL_FRAME (frame);
-
-  if (!self->sync)
-    return FALSE;
-
-  return glClientWaitSync (self->sync, 0, 0) == GL_TIMEOUT_EXPIRED;
-}
-
-static void
-gsk_gl_frame_wait (GskGpuFrame *frame)
-{
-  GskGLFrame *self = GSK_GL_FRAME (frame);
-
-  if (!self->sync)
-    return;
-
-  glClientWaitSync (self->sync, 0, G_MAXINT64);
+  return FALSE;
 }

 static void
@@ -67,12 +50,6 @@ gsk_gl_frame_cleanup (GskGpuFrame *frame)
 {
  GskGLFrame *self = GSK_GL_FRAME (frame);

-  if (self->sync)
-    {
-      glClientWaitSync (self->sync, 0, -1);
-      g_clear_pointer (&self->sync, glDeleteSync);
-    }
-
  self->next_texture_slot = 0;

  GSK_GPU_FRAME_CLASS (gsk_gl_frame_parent_class)->cleanup (frame);
@@ -147,22 +124,14 @@ gsk_gl_frame_create_vertex_buffer (GskGpuFrame *frame,
   */
  g_hash_table_remove_all (self->vaos);

-  if (gdk_gl_context_has_feature (GDK_GL_CONTEXT (gsk_gpu_frame_get_context (frame)),
-                                  GDK_GL_FEATURE_BUFFER_STORAGE))
-    return gsk_gl_mapped_buffer_new (GL_ARRAY_BUFFER, size);
-  else
-    return gsk_gl_copied_buffer_new (GL_ARRAY_BUFFER, size);
+  return gsk_gl_buffer_new (GL_ARRAY_BUFFER, size, GL_WRITE_ONLY);
 }

 static GskGpuBuffer *
 gsk_gl_frame_create_storage_buffer (GskGpuFrame *frame,
                                    gsize        size)
 {
-  if (gdk_gl_context_has_feature (GDK_GL_CONTEXT (gsk_gpu_frame_get_context (frame)),
-                                  GDK_GL_FEATURE_BUFFER_STORAGE))
-    return gsk_gl_mapped_buffer_new (GL_UNIFORM_BUFFER, size);
-  else
-    return gsk_gl_copied_buffer_new (GL_UNIFORM_BUFFER, size);
+  return gsk_gl_buffer_new (GL_UNIFORM_BUFFER, size, GL_WRITE_ONLY);
 }

 static void
@@ -191,10 +160,6 @@ gsk_gl_frame_submit (GskGpuFrame  *frame,
    {
      op = gsk_gpu_op_gl_command (op, frame, &state);
    }
-
-  if (gdk_gl_context_has_feature (GDK_GL_CONTEXT (gsk_gpu_frame_get_context (frame)),
-                                  GDK_GL_FEATURE_SYNC))
-    self->sync = glFenceSync (GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
 }

 static void
@@ -215,7 +180,6 @@ gsk_gl_frame_class_init (GskGLFrameClass *klass)
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  gpu_frame_class->is_busy = gsk_gl_frame_is_busy;
-  gpu_frame_class->wait = gsk_gl_frame_wait;
  gpu_frame_class->setup = gsk_gl_frame_setup;
  gpu_frame_class->cleanup = gsk_gl_frame_cleanup;
  gpu_frame_class->upload_texture = gsk_gl_frame_upload_texture;
@@ -17,16 +17,23 @@ struct _GskGpuBlendModeOp
 };

 static void
-gsk_gpu_blend_mode_op_print_instance (GskGpuShaderOp *shader,
-                                      gpointer        instance_,
-                                      GString        *string)
+gsk_gpu_blend_mode_op_print (GskGpuOp    *op,
+                             GskGpuFrame *frame,
+                             GString     *string,
+                             guint        indent)
 {
-  GskGpuBlendmodeInstance *instance = (GskGpuBlendmodeInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuBlendmodeInstance *instance;

+  instance = (GskGpuBlendmodeInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "blend-mode");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->bottom_id);
  gsk_gpu_print_enum (string, GSK_TYPE_BLEND_MODE, shader->variation);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->top_id);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = {
@@ -34,7 +41,7 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuBlendModeOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_blend_mode_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -45,7 +52,6 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_blendmode_info,
 #endif
-  gsk_gpu_blend_mode_op_print_instance,
  gsk_gpu_blendmode_setup_attrib_locations,
  gsk_gpu_blendmode_setup_vao
 };
@@ -20,15 +20,22 @@ struct _GskGpuBlurOp
 };

 static void
-gsk_gpu_blur_op_print_instance (GskGpuShaderOp *shader,
-                                gpointer        instance_,
-                                GString        *string)
+gsk_gpu_blur_op_print (GskGpuOp    *op,
+                       GskGpuFrame *frame,
+                       GString     *string,
+                       guint        indent)
 {
-  GskGpuBlurInstance *instance = (GskGpuBlurInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuBlurInstance *instance;

+  instance = (GskGpuBlurInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "blur");
+  gsk_gpu_print_shader_info (string, shader->clip);
  g_string_append_printf (string, "%g,%g ", instance->blur_direction[0], instance->blur_direction[1]);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = {
@@ -36,7 +43,7 @@ static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuBlurOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_blur_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -47,7 +54,6 @@ static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_blur_info,
 #endif
-  gsk_gpu_blur_op_print_instance,
  gsk_gpu_blur_setup_attrib_locations,
  gsk_gpu_blur_setup_vao
 };
@@ -25,12 +25,18 @@ color_equal (const float *color1,
 }

 static void
-gsk_gpu_border_op_print_instance (GskGpuShaderOp *shader,
-                                  gpointer        instance_,
-                                  GString        *string)
+gsk_gpu_border_op_print (GskGpuOp    *op,
+                         GskGpuFrame *frame,
+                         GString     *string,
+                         guint        indent)
 {
-  GskGpuBorderInstance *instance = (GskGpuBorderInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuBorderInstance *instance;

+  instance = (GskGpuBorderInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "border");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rounded_rect (string, instance->outline);

  gsk_gpu_print_rgba (string, (const float *) &instance->border_colors[0]);
@@ -52,6 +58,8 @@ gsk_gpu_border_op_print_instance (GskGpuShaderOp *shader,
                              instance->border_widths[2],
                              instance->border_widths[3]);
    }
+
+  gsk_gpu_print_newline (string);
 }

 #ifdef GDK_RENDERING_VULKAN
@@ -77,7 +85,7 @@ static const GskGpuShaderOpClass GSK_GPU_BORDER_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuBorderOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_border_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_border_op_vk_command,
 #endif
@@ -88,7 +96,6 @@ static const GskGpuShaderOpClass GSK_GPU_BORDER_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_border_info,
 #endif
-  gsk_gpu_border_op_print_instance,
  gsk_gpu_border_setup_attrib_locations,
  gsk_gpu_border_setup_vao
 };
@@ -20,17 +20,24 @@ struct _GskGpuBoxShadowOp
 };

 static void
-gsk_gpu_box_shadow_op_print_instance (GskGpuShaderOp *shader,
-                                      gpointer        instance_,
-                                      GString        *string)
+gsk_gpu_box_shadow_op_print (GskGpuOp    *op,
+                             GskGpuFrame *frame,
+                             GString     *string,
+                             guint        indent)
 {
-  GskGpuBoxshadowInstance *instance = (GskGpuBoxshadowInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuBoxshadowInstance *instance;

+  instance = (GskGpuBoxshadowInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, shader->variation & VARIATION_INSET ? "inset-shadow" : "outset-shadow");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rounded_rect (string, instance->outline);
  gsk_gpu_print_rgba (string, instance->color);
  g_string_append_printf (string, "%g %g %g %g ",
                          instance->shadow_offset[0], instance->shadow_offset[1],
                          instance->blur_radius, instance->shadow_spread);
+  gsk_gpu_print_newline (string);
 }

 #ifdef GDK_RENDERING_VULKAN
@@ -56,7 +63,7 @@ static const GskGpuShaderOpClass GSK_GPU_BOX_SHADOW_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuBoxShadowOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_box_shadow_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_box_shadow_op_vk_command,
 #endif
@@ -67,7 +74,6 @@ static const GskGpuShaderOpClass GSK_GPU_BOX_SHADOW_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_boxshadow_info,
 #endif
-  gsk_gpu_box_shadow_op_print_instance,
  gsk_gpu_boxshadow_setup_attrib_locations,
  gsk_gpu_boxshadow_setup_vao
 };
@@ -2,8 +2,6 @@

 #include "gskgpubufferprivate.h"

-#include <gdk/gdkprofilerprivate.h>
-
 typedef struct _GskGpuBufferPrivate GskGpuBufferPrivate;

 struct _GskGpuBufferPrivate
@@ -13,13 +11,9 @@ struct _GskGpuBufferPrivate

 G_DEFINE_TYPE_WITH_PRIVATE (GskGpuBuffer, gsk_gpu_buffer, G_TYPE_OBJECT)

-static guint profiler_buffer_uploads_id;
-static gint64 profiler_buffer_uploads;
-
 static void
 gsk_gpu_buffer_class_init (GskGpuBufferClass *klass)
 {
-  profiler_buffer_uploads_id = gdk_profiler_define_int_counter ("ngl-buffer-uploads", "Number of bytes uploaded to GPU");
 }

 static void
@@ -35,7 +29,7 @@ gsk_gpu_buffer_setup (GskGpuBuffer *self,

  priv->size = size;
 }
-
+                     
 gsize
 gsk_gpu_buffer_get_size (GskGpuBuffer *self)
 {
@@ -51,12 +45,8 @@ gsk_gpu_buffer_map (GskGpuBuffer *self)
 }

 void
-gsk_gpu_buffer_unmap (GskGpuBuffer *self,
-                      gsize         size)
+gsk_gpu_buffer_unmap (GskGpuBuffer *self)
 {
-  GSK_GPU_BUFFER_GET_CLASS (self)->unmap (self, size);
-
-  profiler_buffer_uploads += size;
-  gdk_profiler_set_int_counter (profiler_buffer_uploads_id, profiler_buffer_uploads);
+  GSK_GPU_BUFFER_GET_CLASS (self)->unmap (self);
 }

@@ -23,8 +23,7 @@ struct _GskGpuBufferClass
  GObjectClass parent_class;

  guchar *              (* map)                                         (GskGpuBuffer           *self);
-  void                  (* unmap)                                       (GskGpuBuffer           *self,
-                                                                         gsize                   used);
+  void                  (* unmap)                                       (GskGpuBuffer           *self);
 };

 GType                   gsk_gpu_buffer_get_type                         (void) G_GNUC_CONST;
@@ -35,8 +34,7 @@ void                    gsk_gpu_buffer_setup                            (GskGpuB
 gsize                   gsk_gpu_buffer_get_size                         (GskGpuBuffer           *self);

 guchar *                gsk_gpu_buffer_map                              (GskGpuBuffer           *self);
-void                    gsk_gpu_buffer_unmap                            (GskGpuBuffer           *self,
-                                                                         gsize                   used);
+void                    gsk_gpu_buffer_unmap                            (GskGpuBuffer           *self);


 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuBuffer, g_object_unref)
@@ -30,14 +30,6 @@ gsk_gpu_clip_init_rect (GskGpuClip            *clip,
  gsk_rounded_rect_init_from_rect (&clip->rect, rect, 0);
 }

-static void
-gsk_gpu_clip_init_rounded_rect (GskGpuClip           *self,
-                                const GskRoundedRect *rect)
-{
-  self->type = GSK_GPU_CLIP_ROUNDED;
-  gsk_rounded_rect_init_copy (&self->rect, rect);
-}
-
 void
 gsk_gpu_clip_init_copy (GskGpuClip       *self,
                        const GskGpuClip *src)
@@ -137,13 +129,6 @@ gsk_gpu_clip_intersect_rounded_rect (GskGpuClip           *dest,
      break;

    case GSK_GPU_CLIP_NONE:
-      res = gsk_rounded_rect_intersect_with_rect (rounded, &src->rect.bounds, &dest->rect);
-      if (gsk_gpu_clip_init_after_intersection (dest, res))
-        break;
-      /* XXX: This may grow the bounds quite substantially */
-      gsk_gpu_clip_init_rounded_rect (dest, rounded);
-      break;
-
    case GSK_GPU_CLIP_CONTAINED:
    case GSK_GPU_CLIP_RECT:
      res = gsk_rounded_rect_intersect_with_rect (rounded, &src->rect.bounds, &dest->rect);
@@ -16,7 +16,6 @@ typedef enum {
  GSK_GPU_CLIP_ALL_CLIPPED,
  /* No clipping is necessary, but the clip rect is set
   * to the actual bounds of the underlying framebuffer
-   * or handled via the scissor.
   */
  GSK_GPU_CLIP_NONE,
  /* The clip exists outside the rect, so clipping must
@@ -16,15 +16,22 @@ struct _GskGpuColorizeOp
 };

 static void
-gsk_gpu_colorize_op_print_instance (GskGpuShaderOp *shader,
-                                    gpointer        instance_,
-                                    GString        *string)
+gsk_gpu_colorize_op_print (GskGpuOp    *op,
+                           GskGpuFrame *frame,
+                           GString     *string,
+                           guint        indent)
 {
-  GskGpuColorizeInstance *instance = (GskGpuColorizeInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuColorizeInstance *instance;

+  instance = (GskGpuColorizeInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "colorize");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
  gsk_gpu_print_rgba (string, instance->color);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = {
@@ -32,7 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuColorizeOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_colorize_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -43,7 +50,6 @@ static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_colorize_info,
 #endif
-  gsk_gpu_colorize_op_print_instance,
  gsk_gpu_colorize_setup_attrib_locations,
  gsk_gpu_colorize_setup_vao
 };
@@ -16,14 +16,21 @@ struct _GskGpuColorMatrixOp
 };

 static void
-gsk_gpu_color_matrix_op_print_instance (GskGpuShaderOp *shader,
-                                        gpointer        instance_,
-                                        GString        *string)
+gsk_gpu_color_matrix_op_print (GskGpuOp    *op,
+                               GskGpuFrame *frame,
+                               GString     *string,
+                               guint        indent)
 {
-  GskGpuColormatrixInstance *instance = (GskGpuColormatrixInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuColormatrixInstance *instance;

+  instance = (GskGpuColormatrixInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "color-matrix");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = {
@@ -31,7 +38,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuColorMatrixOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_color_matrix_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -42,7 +49,6 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_colormatrix_info,
 #endif
-  gsk_gpu_color_matrix_op_print_instance,
  gsk_gpu_colormatrix_setup_attrib_locations,
  gsk_gpu_colormatrix_setup_vao
 };
@@ -17,14 +17,21 @@ struct _GskGpuColorOp
 };

 static void
-gsk_gpu_color_op_print_instance (GskGpuShaderOp *shader,
-                                 gpointer        instance_,
-                                 GString        *string)
+gsk_gpu_color_op_print (GskGpuOp    *op,
+                        GskGpuFrame *frame,
+                        GString     *string,
+                        guint        indent)
 {
-  GskGpuColorInstance *instance = (GskGpuColorInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuColorInstance *instance;

+  instance = (GskGpuColorInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "color");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_rgba (string, instance->color);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_COLOR_OP_CLASS = {
@@ -32,7 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuColorOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_color_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -43,7 +50,6 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_color_info,
 #endif
-  gsk_gpu_color_op_print_instance,
  gsk_gpu_color_setup_attrib_locations,
  gsk_gpu_color_setup_vao
 };
@@ -18,13 +18,20 @@ struct _GskGpuConicGradientOp
 };

 static void
-gsk_gpu_conic_gradient_op_print_instance (GskGpuShaderOp *shader,
-                                          gpointer        instance_,
-                                          GString        *string)
+gsk_gpu_conic_gradient_op_print (GskGpuOp    *op,
+                                 GskGpuFrame *frame,
+                                 GString     *string,
+                                 guint        indent)
 {
-  GskGpuConicgradientInstance *instance = (GskGpuConicgradientInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuConicgradientInstance *instance;

+  instance = (GskGpuConicgradientInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "conic-gradient");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_CONIC_GRADIENT_OP_CLASS = {
@@ -32,7 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_CONIC_GRADIENT_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuConicGradientOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_conic_gradient_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -43,7 +50,6 @@ static const GskGpuShaderOpClass GSK_GPU_CONIC_GRADIENT_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_conicgradient_info,
 #endif
-  gsk_gpu_conic_gradient_op_print_instance,
  gsk_gpu_conicgradient_setup_attrib_locations,
  gsk_gpu_conicgradient_setup_vao
 };
@@ -16,16 +16,23 @@ struct _GskGpuCrossFadeOp
 };

 static void
-gsk_gpu_cross_fade_op_print_instance (GskGpuShaderOp *shader,
-                                      gpointer        instance_,
-                                      GString        *string)
+gsk_gpu_cross_fade_op_print (GskGpuOp    *op,
+                             GskGpuFrame *frame,
+                             GString     *string,
+                             guint        indent)
 {
-  GskGpuCrossfadeInstance *instance = (GskGpuCrossfadeInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuCrossfadeInstance *instance;

+  instance = (GskGpuCrossfadeInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "cross-fade");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->start_id);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->end_id);
  g_string_append_printf (string, "%g%%", 100 * instance->opacity_progress[1]);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = {
@@ -33,7 +40,7 @@ static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuCrossFadeOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_cross_fade_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -44,7 +51,6 @@ static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_crossfade_info,
 #endif
-  gsk_gpu_cross_fade_op_print_instance,
  gsk_gpu_crossfade_setup_attrib_locations,
  gsk_gpu_crossfade_setup_vao
 };
@@ -33,6 +33,37 @@ typedef struct _GskGpuCachedGlyph GskGpuCachedGlyph;
 typedef struct _GskGpuCachedTexture GskGpuCachedTexture;
 typedef struct _GskGpuDevicePrivate GskGpuDevicePrivate;

+typedef struct {
+  PangoFont *font;
+  float scale;
+} FontCacheKey;
+
+typedef struct {
+  PangoGlyph glyph;
+  GskGpuGlyphLookupFlags flags;
+} GlyphCacheKey;
+
+typedef struct {
+  FontCacheKey key;
+
+  GHashTable *cache;
+} FontGlyphCache;
+
+static void
+font_glyph_cache_free (gpointer data)
+{
+  FontGlyphCache *cache = data;
+
+  g_object_unref (cache->key.font);
+  g_hash_table_unref (cache->cache);
+  g_free (cache);
+}
+
+static FontGlyphCache no_font_cache = {
+  .key = { .font = NULL, .scale = -1 },
+  .cache = NULL
+};
+
 struct _GskGpuDevicePrivate
 {
  GdkDisplay *display;
@@ -45,6 +76,7 @@ struct _GskGpuDevicePrivate

  GHashTable *texture_cache;
  GHashTable *glyph_cache;
+  FontGlyphCache *last_font_cache;

  GskGpuCachedAtlas *current_atlas;

@@ -69,14 +101,15 @@ struct _GskGpuCachedClass
 struct _GskGpuCached
 {
  const GskGpuCachedClass *class;
-
  GskGpuCachedAtlas *atlas;
  GskGpuCached *next;
  GskGpuCached *prev;

  gint64 timestamp;
-  gboolean stale;
-  guint pixels;   /* For glyphs and textures, pixels. For atlases, dead pixels */
+
+  unsigned int stale  : 1;
+  unsigned int pixels : 31;   /* For glyphs and textures, pixels. For atlases, dead pixels */
+
 };

 static inline void
@@ -361,10 +394,8 @@ struct _GskGpuCachedGlyph
 {
  GskGpuCached parent;

-  PangoFont *font;
-  PangoGlyph glyph;
-  GskGpuGlyphLookupFlags flags;
-  float scale;
+  FontGlyphCache *font_cache;
+  GlyphCacheKey glyph_key;

  GskGpuImage *image;
  graphene_rect_t bounds;
@@ -377,10 +408,17 @@ gsk_gpu_cached_glyph_free (GskGpuDevice *device,
 {
  GskGpuDevicePrivate *priv = gsk_gpu_device_get_instance_private (device);
  GskGpuCachedGlyph *self = (GskGpuCachedGlyph *) cached;
+  FontGlyphCache *font_cache;

-  g_hash_table_remove (priv->glyph_cache, self);
+  font_cache = self->font_cache;
+  g_hash_table_remove (font_cache->cache, self);
+  if (g_hash_table_size (font_cache->cache) == 0)
+    {
+      if (priv->last_font_cache == font_cache)
+        priv->last_font_cache = &no_font_cache;
+      g_hash_table_remove (priv->glyph_cache, font_cache);
+    }

-  g_object_unref (self->font);
  g_object_unref (self->image);

  g_free (self);
@@ -403,15 +441,35 @@ gsk_gpu_cached_glyph_should_collect (GskGpuDevice *device,
  return FALSE;
 }

+static guint
+gsk_gpu_cached_font_hash (gconstpointer data)
+{
+  const FontGlyphCache *cache = data;
+  const FontCacheKey *key = &cache->key;
+
+  return GPOINTER_TO_UINT (key->font) ^ ((guint) key->scale * PANGO_SCALE);
+}
+
+static gboolean
+gsk_gpu_cached_font_equal (gconstpointer v1,
+                           gconstpointer v2)
+{
+  const FontGlyphCache *c1 = v1;
+  const FontCacheKey *key1 = &c1->key;
+  const FontGlyphCache *c2 = v2;
+  const FontCacheKey *key2 = &c2->key;
+
+  return key1->font == key2->font &&
+         key1->scale == key2->scale;
+}
+
 static guint
 gsk_gpu_cached_glyph_hash (gconstpointer data)
 {
  const GskGpuCachedGlyph *glyph = data;
+  const GlyphCacheKey *key = &glyph->glyph_key;

-  return GPOINTER_TO_UINT (glyph->font) ^
-         glyph->glyph ^
-         (glyph->flags << 24) ^
-         ((guint) glyph->scale * PANGO_SCALE);
+  return key->glyph ^ (key->flags << 24);
 }

 static gboolean
@@ -420,11 +478,11 @@ gsk_gpu_cached_glyph_equal (gconstpointer v1,
 {
  const GskGpuCachedGlyph *glyph1 = v1;
  const GskGpuCachedGlyph *glyph2 = v2;
+  const GlyphCacheKey *key1 = &glyph1->glyph_key;
+  const GlyphCacheKey *key2 = &glyph2->glyph_key;

-  return glyph1->font == glyph2->font
-      && glyph1->glyph == glyph2->glyph
-      && glyph1->flags == glyph2->flags
-      && glyph1->scale == glyph2->scale;
+  return key1->glyph == key2->glyph &&
+         key1->flags == key2->flags;
 }

 static const GskGpuCachedClass GSK_GPU_CACHED_GLYPH_CLASS =
@@ -623,10 +681,13 @@ gsk_gpu_device_init (GskGpuDevice *self)
 {
  GskGpuDevicePrivate *priv = gsk_gpu_device_get_instance_private (self);

-  priv->glyph_cache = g_hash_table_new (gsk_gpu_cached_glyph_hash,
-                                        gsk_gpu_cached_glyph_equal);
+  priv->glyph_cache = g_hash_table_new_full (gsk_gpu_cached_font_hash,
+                                             gsk_gpu_cached_font_equal,
+                                             NULL,
+                                             font_glyph_cache_free);
  priv->texture_cache = g_hash_table_new (g_direct_hash,
                                          g_direct_equal);
+  priv->last_font_cache = &no_font_cache;
 }

 void
@@ -890,16 +951,18 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
                                   GskGpuGlyphLookupFlags  flags,
                                   float                   scale,
                                   graphene_rect_t        *out_bounds,
-                                   graphene_point_t       *out_origin)
+                                   graphene_point_t       *out_origin,
+                                   PangoFont             **out_scaled_font)
 {
  GskGpuDevicePrivate *priv = gsk_gpu_device_get_instance_private (self);
-  GskGpuCachedGlyph lookup = {
-    .font = font,
-    .glyph = glyph,
-    .flags = flags,
-    .scale = scale
+  FontGlyphCache font_lookup = {
+    .key = { .font = font, .scale = scale }
  };
-  GskGpuCachedGlyph *cache;
+  GskGpuCachedGlyph glyph_lookup = {
+    .glyph_key = { .glyph = glyph, .flags = flags }
+  };
+  FontGlyphCache *font_cache = NULL;
+  GskGpuCachedGlyph *cache = NULL;
  PangoRectangle ink_rect;
  graphene_rect_t rect;
  graphene_point_t origin;
@@ -908,22 +971,43 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
  float subpixel_x, subpixel_y;
  PangoFont *scaled_font;

-  cache = g_hash_table_lookup (priv->glyph_cache, &lookup);
-  if (cache)
-    {
-      gsk_gpu_cached_use (self, (GskGpuCached *) cache, gsk_gpu_frame_get_timestamp (frame));
+  if (priv->last_font_cache->key.font == font &&
+      priv->last_font_cache->key.scale == scale)
+    font_cache = priv->last_font_cache;
+  else
+    font_cache = g_hash_table_lookup (priv->glyph_cache, &font_lookup);

-      *out_bounds = cache->bounds;
-      *out_origin = cache->origin;
-      return cache->image;
+  if (font_cache)
+    {
+      cache = g_hash_table_lookup (font_cache->cache, &glyph_lookup);
+      if (cache)
+        {
+          gsk_gpu_cached_use (self, (GskGpuCached *) cache, gsk_gpu_frame_get_timestamp (frame));
+
+          *out_bounds = cache->bounds;
+          *out_origin = cache->origin;
+
+          priv->last_font_cache = font_cache;
+
+          return cache->image;
+        }
+    }
+  else
+    {
+      font_cache = g_new (FontGlyphCache, 1);
+      font_cache->key.font = g_object_ref (font);
+      font_cache->key.scale = scale;
+      font_cache->cache = g_hash_table_new (gsk_gpu_cached_glyph_hash,
+                                            gsk_gpu_cached_glyph_equal);
+      g_hash_table_insert (priv->glyph_cache, font_cache, font_cache);
    }

-  /* Note: we want to scale the font to the required size *and* ensure that
-   * metrics hinting is off. The latter is necessary since pango lets metrics
-   * hinting influence the rendering of hexboxes, and we get bad outcomes if
-   * that happens.
-   */
-  scaled_font = gsk_reload_font (font, scale, CAIRO_HINT_METRICS_OFF, CAIRO_HINT_STYLE_DEFAULT, CAIRO_ANTIALIAS_DEFAULT);
+  priv->last_font_cache = font_cache;
+
+  if (*out_scaled_font)
+    scaled_font = *out_scaled_font;
+  else
+    scaled_font = gsk_get_scaled_font (font, scale);

  subpixel_x = (flags & 3) / 4.f;
  subpixel_y = ((flags >> 2) & 3) / 4.f;
@@ -953,10 +1037,9 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
      cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS, NULL);
    }

-  cache->font = g_object_ref (font);
-  cache->glyph = glyph;
-  cache->flags = flags;
-  cache->scale = scale;
+  cache->font_cache = font_cache;
+  cache->glyph_key.glyph = glyph;
+  cache->glyph_key.flags = flags;
  cache->bounds = rect;
  cache->image = image;
  cache->origin = GRAPHENE_POINT_INIT (- origin.x + subpixel_x,
@@ -976,13 +1059,12 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
                           &GRAPHENE_POINT_INIT (cache->origin.x + padding,
                                                 cache->origin.y + padding));

-  g_hash_table_insert (priv->glyph_cache, cache, cache);
+  g_hash_table_insert (font_cache->cache, cache, cache);
  gsk_gpu_cached_use (self, (GskGpuCached *) cache, gsk_gpu_frame_get_timestamp (frame));

  *out_bounds = cache->bounds;
  *out_origin = cache->origin;
-
-  g_object_unref (scaled_font);
+  *out_scaled_font = scaled_font;

  return cache->image;
 }
@@ -96,7 +96,8 @@ GskGpuImage *           gsk_gpu_device_lookup_glyph_image               (GskGpuD
                                                                         GskGpuGlyphLookupFlags  flags,
                                                                         float                   scale,
                                                                         graphene_rect_t        *out_bounds,
-                                                                         graphene_point_t       *out_origin);
+                                                                         graphene_point_t       *out_origin,
+                                                                         PangoFont             **out_scaled_font);


 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDevice, g_object_unref)
@@ -126,7 +126,7 @@ gsk_gpu_download_op_vk_create (GskGpuDownloadOp *self)
                                          bytes,
                                          stride);
  g_bytes_unref (bytes);
-  gsk_gpu_buffer_unmap (self->buffer, 0);
+  gsk_gpu_buffer_unmap (self->buffer);
 }

 static GskGpuOp *
@@ -272,7 +272,7 @@ gsk_gpu_download_op_gl_command (GskGpuOp          *op,
  data->context = g_object_ref (context);
  data->texture_id = gsk_gl_image_steal_texture (GSK_GL_IMAGE (self->image));

-  if (gdk_gl_context_has_feature (context, GDK_GL_FEATURE_SYNC))
+  if (gdk_gl_context_has_sync (context))
    data->sync = glFenceSync (GL_SYNC_GPU_COMMANDS_COMPLETE, 0);

  builder = gdk_gl_texture_builder_new ();
@@ -40,7 +40,6 @@ struct _GskGpuFramePrivate

  GskGpuOps ops;
  GskGpuOp *first_op;
-  GskGpuOp *last_op;

  GskGpuBuffer *vertex_buffer;
  guchar *vertex_buffer_data;
@@ -71,8 +70,6 @@ gsk_gpu_frame_default_cleanup (GskGpuFrame *self)
      gsk_gpu_op_finish (op);
    }
  gsk_gpu_ops_set_size (&priv->ops, 0);
-
-  priv->last_op = NULL;
 }

 static void
@@ -251,35 +248,27 @@ gsk_gpu_frame_sort_render_pass (GskGpuFrame *self,
                                SortData    *sort_data)
 {
  SortData subpasses = { { NULL, NULL }, { NULL, NULL } };
-  SortData pass = { { NULL, NULL }, { NULL, NULL } };
-
-  if (op->op_class->stage == GSK_GPU_STAGE_BEGIN_PASS)
-    {
-      pass.command.first = op;
-      pass.command.last = op;
-      op = op->next;
-    }

  while (op)
    {
      switch (op->op_class->stage)
      {
        case GSK_GPU_STAGE_UPLOAD:
-          if (pass.upload.first == NULL)
-            pass.upload.first = op;
+          if (sort_data->upload.first == NULL)
+            sort_data->upload.first = op;
          else
-            pass.upload.last->next = op;
-          pass.upload.last = op;
+            sort_data->upload.last->next = op;
+          sort_data->upload.last = op;
          op = op->next;
          break;

        case GSK_GPU_STAGE_COMMAND:
        case GSK_GPU_STAGE_SHADER:
-          if (pass.command.first == NULL)
-            pass.command.first = op;
+          if (sort_data->command.first == NULL)
+            sort_data->command.first = op;
          else
-            pass.command.last->next = op;
-          pass.command.last = op;
+            sort_data->command.last->next = op;
+          sort_data->command.last = op;
          op = op->next;
          break;

@@ -293,13 +282,19 @@ gsk_gpu_frame_sort_render_pass (GskGpuFrame *self,
          break;

        case GSK_GPU_STAGE_BEGIN_PASS:
+          if (subpasses.command.first == NULL)
+            subpasses.command.first = op;
+          else
+            subpasses.command.last->next = op;
+          subpasses.command.last = op;
+
          /* append subpass to existing subpasses */
-          op = gsk_gpu_frame_sort_render_pass (self, op, &subpasses);
+          op = gsk_gpu_frame_sort_render_pass (self, op->next, &subpasses);
          break;

        case GSK_GPU_STAGE_END_PASS:
-          pass.command.last->next = op;
-          pass.command.last = op;
+          sort_data->command.last->next = op;
+          sort_data->command.last = op;
          op = op->next;
          goto out;

@@ -310,38 +305,22 @@ gsk_gpu_frame_sort_render_pass (GskGpuFrame *self,
    }

 out:
-  /* append to the sort data, first the subpasses, then the current pass */
+  /* prepend subpasses to the current pass */
  if (subpasses.upload.first)
    {
      if (sort_data->upload.first != NULL)
-        sort_data->upload.last->next = subpasses.upload.first;
+        subpasses.upload.last->next = sort_data->upload.first;
      else
-        sort_data->upload.first = subpasses.upload.first;
-      sort_data->upload.last = subpasses.upload.last;
-    }
-  if (pass.upload.first)
-    {
-      if (sort_data->upload.first != NULL)
-        sort_data->upload.last->next = pass.upload.first;
-      else
-        sort_data->upload.first = pass.upload.first;
-      sort_data->upload.last = pass.upload.last;
+        sort_data->upload.last = subpasses.upload.last;
+      sort_data->upload.first = subpasses.upload.first;
    }
  if (subpasses.command.first)
    {
      if (sort_data->command.first != NULL)
-        sort_data->command.last->next = subpasses.command.first;
+        subpasses.command.last->next = sort_data->command.first;
      else
-        sort_data->command.first = subpasses.command.first;
-      sort_data->command.last = subpasses.command.last;
-    }
-  if (pass.command.first)
-    {
-      if (sort_data->command.first != NULL)
-        sort_data->command.last->next = pass.command.first;
-      else
-        sort_data->command.first = pass.command.first;
-      sort_data->command.last = pass.command.last;
+        sort_data->command.last = subpasses.command.last;
+      sort_data->command.first = subpasses.command.first;
    }

  return op;
@@ -352,13 +331,8 @@ gsk_gpu_frame_sort_ops (GskGpuFrame *self)
 {
  GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self);
  SortData sort_data = { { NULL, }, };
-  GskGpuOp *op;
-
-  op = priv->first_op;
-  while (op)
-    {
-      op = gsk_gpu_frame_sort_render_pass (self, op, &sort_data);
-    }
+  
+  gsk_gpu_frame_sort_render_pass (self, priv->first_op, &sort_data);

  if (sort_data.upload.first)
    {
@@ -369,8 +343,6 @@ gsk_gpu_frame_sort_ops (GskGpuFrame *self)
    priv->first_op = sort_data.command.first;
  if (sort_data.command.last)
    sort_data.command.last->next = NULL;
-
-  priv->last_op = NULL;
 }

 gpointer
@@ -388,17 +360,7 @@ gsk_gpu_frame_alloc_op (GskGpuFrame *self,
                      NULL,
                      size);

-  priv->last_op = (GskGpuOp *) gsk_gpu_ops_index (&priv->ops, pos);
-
-  return priv->last_op;
-}
-
-GskGpuOp *
-gsk_gpu_frame_get_last_op (GskGpuFrame *self)
-{
-  GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self);
-
-  return priv->last_op;
+  return gsk_gpu_ops_index (&priv->ops, pos);
 }

 GskGpuImage *
@@ -464,7 +426,7 @@ gsk_gpu_frame_reserve_vertex_data (GskGpuFrame *self,
      if (priv->vertex_buffer_data)
        {
          memcpy (new_data, priv->vertex_buffer_data, old_size);
-          gsk_gpu_buffer_unmap (priv->vertex_buffer, old_size);
+          gsk_gpu_buffer_unmap (priv->vertex_buffer);
        }
      g_object_unref (priv->vertex_buffer);
      priv->vertex_buffer = new_buffer;
@@ -472,7 +434,7 @@ gsk_gpu_frame_reserve_vertex_data (GskGpuFrame *self,
    }

  priv->vertex_buffer_used = size_needed;
-
+  
  return size_needed - size;
 }

@@ -518,7 +480,7 @@ gsk_gpu_frame_write_storage_buffer (GskGpuFrame  *self,
    {
      g_assert (offset > 0);

-      gsk_gpu_buffer_unmap (priv->storage_buffer, 0);
+      gsk_gpu_buffer_unmap (priv->storage_buffer);
      g_clear_object (&priv->storage_buffer);
      priv->storage_buffer_data = 0;
      priv->storage_buffer_used = 0;
@@ -543,12 +505,6 @@ gsk_gpu_frame_is_busy (GskGpuFrame *self)
  return GSK_GPU_FRAME_GET_CLASS (self)->is_busy (self);
 }

-void
-gsk_gpu_frame_wait (GskGpuFrame *self)
-{
-  GSK_GPU_FRAME_GET_CLASS (self)->wait (self);
-}
-
 static void
 copy_texture (gpointer    user_data,
              GdkTexture *texture)
@@ -635,14 +591,14 @@ gsk_gpu_frame_submit (GskGpuFrame *self)

  if (priv->vertex_buffer)
    {
-      gsk_gpu_buffer_unmap (priv->vertex_buffer, priv->vertex_buffer_used);
+      gsk_gpu_buffer_unmap (priv->vertex_buffer);
      priv->vertex_buffer_data = NULL;
      priv->vertex_buffer_used = 0;
    }

  if (priv->storage_buffer_data)
    {
-      gsk_gpu_buffer_unmap (priv->storage_buffer, priv->storage_buffer_used);
+      gsk_gpu_buffer_unmap (priv->storage_buffer);
      priv->storage_buffer_data = NULL;
      priv->storage_buffer_used = 0;
    }
@@ -24,7 +24,6 @@ struct _GskGpuFrameClass
  GObjectClass parent_class;

  gboolean              (* is_busy)                                     (GskGpuFrame            *self);
-  void                  (* wait)                                        (GskGpuFrame            *self);
  void                  (* setup)                                       (GskGpuFrame            *self);
  void                  (* cleanup)                                     (GskGpuFrame            *self);
  GskGpuImage *         (* upload_texture)                              (GskGpuFrame            *self,
@@ -70,7 +69,6 @@ GskGpuBuffer *          gsk_gpu_frame_write_storage_buffer              (GskGpuF
                                                                         gsize                  *out_offset);

 gboolean                gsk_gpu_frame_is_busy                           (GskGpuFrame            *self);
-void                    gsk_gpu_frame_wait                              (GskGpuFrame            *self);

 void                    gsk_gpu_frame_render                            (GskGpuFrame            *self,
                                                                         gint64                  timestamp,
@@ -85,7 +83,6 @@ void                    gsk_gpu_frame_download_texture                  (GskGpuF
                                                                         GdkMemoryFormat         format,
                                                                         guchar                 *data,
                                                                         gsize                   stride);
-GskGpuOp               *gsk_gpu_frame_get_last_op                       (GskGpuFrame            *self);

 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuFrame, g_object_unref)

@@ -19,15 +19,23 @@ struct _GskGpuLinearGradientOp
 };

 static void
-gsk_gpu_linear_gradient_op_print_instance (GskGpuShaderOp *shader,
-                                           gpointer        instance_,
-                                           GString        *string)
+gsk_gpu_linear_gradient_op_print (GskGpuOp    *op,
+                                  GskGpuFrame *frame,
+                                  GString     *string,
+                                  guint        indent)
 {
-  GskGpuLineargradientInstance *instance = (GskGpuLineargradientInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuLineargradientInstance *instance;
+
+  instance = (GskGpuLineargradientInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);

  if (shader->variation & VARIATION_REPEATING)
-    gsk_gpu_print_string (string, "repeating");
+    gsk_gpu_print_op (string, indent, "repeating-linear-gradient");
+  else
+    gsk_gpu_print_op (string, indent, "linear-gradient");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_LINEAR_GRADIENT_OP_CLASS = {
@@ -35,7 +43,7 @@ static const GskGpuShaderOpClass GSK_GPU_LINEAR_GRADIENT_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuLinearGradientOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_linear_gradient_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -46,7 +54,6 @@ static const GskGpuShaderOpClass GSK_GPU_LINEAR_GRADIENT_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_lineargradient_info,
 #endif
-  gsk_gpu_linear_gradient_op_print_instance,
  gsk_gpu_lineargradient_setup_attrib_locations,
  gsk_gpu_lineargradient_setup_vao
 };
@@ -16,15 +16,22 @@ struct _GskGpuMaskOp
 };

 static void
-gsk_gpu_mask_op_print_instance (GskGpuShaderOp *shader,
-                                gpointer        instance_,
-                                GString        *string)
+gsk_gpu_mask_op_print (GskGpuOp    *op,
+                       GskGpuFrame *frame,
+                       GString     *string,
+                       guint        indent)
 {
-  GskGpuMaskInstance *instance = (GskGpuMaskInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuMaskInstance *instance;

+  instance = (GskGpuMaskInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "mask");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->source_id);
  gsk_gpu_print_image_descriptor (string, shader->desc, instance->mask_id);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = {
@@ -32,7 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuMaskOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_mask_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -43,7 +50,6 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_mask_info,
 #endif
-  gsk_gpu_mask_op_print_instance,
  gsk_gpu_mask_setup_attrib_locations,
  gsk_gpu_mask_setup_vao
 };
@@ -40,7 +40,6 @@
 #include "gskroundedrectprivate.h"
 #include "gskstrokeprivate.h"
 #include "gsktransformprivate.h"
-#include "gskprivate.h"

 #include "gdk/gdkrgbaprivate.h"
 #include "gdk/gdksubsurfaceprivate.h"
@@ -184,13 +183,13 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
    {
      float scale_x = viewport->size.width / width;
      float scale_y = viewport->size.height / height;
-      gsk_gpu_clip_init_empty (&self->clip,
-                               &GRAPHENE_RECT_INIT (
-                                   scale_x * clip->x,
-                                   scale_y * clip->y,
-                                   scale_x * clip->width,
-                                   scale_y * clip->height
-                               ));
+      gsk_gpu_clip_init_rect (&self->clip,
+                              &GRAPHENE_RECT_INIT (
+                                  scale_x * clip->x,
+                                  scale_y * clip->y,
+                                  scale_x * clip->width,
+                                  scale_y * clip->height
+                              ));
    }

  self->modelview = NULL;
@@ -1328,7 +1327,7 @@ gsk_gpu_node_processor_add_node_clipped (GskGpuNodeProcessor   *self,
              gsk_gpu_clip_init_copy (&self->clip, &old_clip);
              return;
            }
-          else if ((self->clip.type == GSK_GPU_CLIP_RECT || self->clip.type == GSK_GPU_CLIP_CONTAINED) &&
+          else if (self->clip.type == GSK_GPU_CLIP_RECT &&
                   gsk_rect_contains_rect (&self->clip.rect.bounds, &clip))
            {
              self->clip.type = GSK_GPU_CLIP_NONE;
@@ -1611,7 +1610,7 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
            inverse = gsk_transform_invert (gsk_transform_ref (clip_transform));
            gsk_transform_transform_bounds (inverse, &old_clip.rect.bounds, &new_bounds);
            gsk_transform_unref (inverse);
-            gsk_gpu_clip_init_empty (&self->clip, &new_bounds);
+            gsk_gpu_clip_init_contained (&self->clip, &new_bounds);
          }
        else if (!gsk_gpu_clip_transform (&self->clip, &old_clip, clip_transform, &child->bounds))
          {
@@ -1649,13 +1648,10 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,

        extract_scale_from_transform (self->modelview, &scale_x, &scale_y);

-        old_pixels = MAX (graphene_vec2_get_x (&old_scale) * old_clip.rect.bounds.size.width,
-                          graphene_vec2_get_y (&old_scale) * old_clip.rect.bounds.size.height);
-        new_pixels = MAX (scale_x * self->clip.rect.bounds.size.width,
-                          scale_y * self->clip.rect.bounds.size.height);
-
-        /* Check that our offscreen doesn't get too big.  1.5 ~ sqrt(2) */
-        if (new_pixels > 1.5 * old_pixels)
+        old_pixels = graphene_vec2_get_x (&old_scale) * graphene_vec2_get_y (&old_scale) *
+                     old_clip.rect.bounds.size.width * old_clip.rect.bounds.size.height;
+        new_pixels = scale_x * scale_y * self->clip.rect.bounds.size.width * self->clip.rect.bounds.size.height;
+        if (new_pixels > 2 * old_pixels)
          {
            float forced_downscale = 2 * old_pixels / new_pixels;
            scale_x *= forced_downscale;
@@ -2059,7 +2055,7 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
  guint32 descriptor;
  gboolean need_mipmap, need_offscreen;

-  need_offscreen = self->modelview != NULL ||
+  need_offscreen = self->modelview != NULL || 
            !graphene_vec2_equal (&self->scale, graphene_vec2_one ());
  if (need_offscreen)
    {
@@ -2996,16 +2992,15 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
  GskGpuDevice *device;
  const PangoGlyphInfo *glyphs;
  PangoFont *font;
+  PangoFont *scaled_font = NULL;
  graphene_point_t offset;
  guint i, num_glyphs;
  float scale, inv_scale;
  GdkRGBA color;
-  float align_scale_x, align_scale_y;
-  float inv_align_scale_x, inv_align_scale_y;
-  unsigned int flags_mask;
+  gboolean glyph_align;
  GskGpuImage *last_image;
-  guint32 descriptor;
-  const float inv_pango_scale = 1.f / PANGO_SCALE;
+  guint32 descriptor = 0;
+  GskGpuClip old_clip;

  if (self->opacity < 1.0 &&
      gsk_text_node_has_color_glyphs (node))
@@ -3014,8 +3009,13 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
      return;
    }

-  device = gsk_gpu_frame_get_device (self->frame);
+  gsk_gpu_clip_init_copy (&old_clip, &self->clip);
+  if (gsk_gpu_clip_contains_rect (&self->clip, &self->offset, &node->bounds))
+    gsk_gpu_clip_init_contained (&self->clip, &node->bounds);

+  glyph_align = gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_GLYPH_ALIGN) &&
+                gsk_transform_get_category (self->modelview) >= GSK_TRANSFORM_CATEGORY_2D;
+  device = gsk_gpu_frame_get_device (self->frame);
  color = *gsk_text_node_get_color (node);
  color.alpha *= self->opacity;
  num_glyphs = gsk_text_node_get_num_glyphs (node);
@@ -3028,23 +3028,7 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
  inv_scale = 1.f / scale;

-  if (gsk_font_get_hint_style (font) != CAIRO_HINT_STYLE_NONE)
-    {
-      align_scale_x = scale * 4;
-      align_scale_y = scale;
-      flags_mask = 3;
-    }
-  else
-    {
-      align_scale_x = align_scale_y = scale * 4;
-      flags_mask = 15;
-    }
-
-  inv_align_scale_x = 1 / align_scale_x;
-  inv_align_scale_y = 1 / align_scale_y;
-
  last_image = NULL;
-  descriptor = 0;
  for (i = 0; i < num_glyphs; i++)
    {
      GskGpuImage *image;
@@ -3052,14 +3036,21 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
      graphene_point_t glyph_offset, glyph_origin;
      GskGpuGlyphLookupFlags flags;

-      glyph_origin = GRAPHENE_POINT_INIT (offset.x + glyphs[i].geometry.x_offset * inv_pango_scale,
-                                          offset.y + glyphs[i].geometry.y_offset * inv_pango_scale);
-
-      glyph_origin.x = floorf (glyph_origin.x * align_scale_x + 0.5f);
-      glyph_origin.y = floorf (glyph_origin.y * align_scale_y + 0.5f);
-      flags = (((int) glyph_origin.x & 3) | (((int) glyph_origin.y & 3) << 2)) & flags_mask;
-      glyph_origin.x *= inv_align_scale_x;
-      glyph_origin.y *= inv_align_scale_y;
+      glyph_origin = GRAPHENE_POINT_INIT (offset.x + (float) glyphs[i].geometry.x_offset / PANGO_SCALE,
+                                          offset.y + (float) glyphs[i].geometry.y_offset / PANGO_SCALE);
+      if (glyph_align)
+        {
+          glyph_origin.x = roundf (glyph_origin.x * scale * 4);
+          glyph_origin.y = roundf (glyph_origin.y * scale * 4);
+          flags = ((int) glyph_origin.x & 3) |
+                  (((int) glyph_origin.y & 3) << 2);
+          glyph_origin.x = 0.25 * inv_scale * glyph_origin.x;
+          glyph_origin.y = 0.25 * inv_scale * glyph_origin.y;
+        }
+      else
+        {
+          flags = 0;
+        }

      image = gsk_gpu_device_lookup_glyph_image (device,
                                                 self->frame,
@@ -3068,16 +3059,11 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
                                                 flags,
                                                 scale,
                                                 &glyph_bounds,
-                                                 &glyph_offset);
+                                                 &glyph_offset,
+                                                 &scaled_font);

-      glyph_tex_rect = GRAPHENE_RECT_INIT (-glyph_bounds.origin.x * inv_scale,
-                                           -glyph_bounds.origin.y * inv_scale,
-                                           gsk_gpu_image_get_width (image) * inv_scale,
-                                           gsk_gpu_image_get_height (image) * inv_scale);
-      glyph_bounds = GRAPHENE_RECT_INIT (0,
-                                         0,
-                                         glyph_bounds.size.width * inv_scale,
-                                         glyph_bounds.size.height * inv_scale);
+      gsk_rect_scale (&GRAPHENE_RECT_INIT (-glyph_bounds.origin.x, -glyph_bounds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), inv_scale, inv_scale, &glyph_tex_rect);
+      gsk_rect_scale (&GRAPHENE_RECT_INIT(0, 0, glyph_bounds.size.width, glyph_bounds.size.height), inv_scale, inv_scale, &glyph_bounds);
      glyph_origin = GRAPHENE_POINT_INIT (glyph_origin.x - glyph_offset.x * inv_scale,
                                          glyph_origin.y - glyph_offset.y * inv_scale);

@@ -3105,8 +3091,12 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
                             &glyph_tex_rect,
                             &color);

-      offset.x += glyphs[i].geometry.width * inv_pango_scale;
+      offset.x += (float) glyphs[i].geometry.width / PANGO_SCALE;
    }
+
+  g_clear_object (&scaled_font);
+
+  gsk_gpu_clip_init_copy (&self->clip, &old_clip);
 }

 static gboolean
@@ -3116,16 +3106,13 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
  GskGpuDevice *device;
  const PangoGlyphInfo *glyphs;
  PangoFont *font;
+  PangoFont *scaled_font = NULL;
  guint num_glyphs;
  gsize i;
  float scale, inv_scale;
  guint32 tex_id;
  GskGpuImage *last_image;
  graphene_point_t offset;
-  float align_scale_x, align_scale_y;
-  float inv_align_scale_x, inv_align_scale_y;
-  unsigned int flags_mask;
-  const float inv_pango_scale = 1.f / PANGO_SCALE;

  if (gsk_text_node_has_color_glyphs (node))
    return FALSE;
@@ -3145,57 +3132,33 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
  gsk_gpu_pattern_writer_append_rgba (self, gsk_text_node_get_color (node));
  gsk_gpu_pattern_writer_append_uint (self, num_glyphs);

-  if (gsk_font_get_hint_style (font) != CAIRO_HINT_STYLE_NONE)
-    {
-      align_scale_x = scale * 4;
-      align_scale_y = scale;
-      flags_mask = 3;
-    }
-  else
-    {
-      align_scale_x = align_scale_y = scale * 4;
-      flags_mask = 15;
-    }
-
-  inv_align_scale_x = 1 / align_scale_x;
-  inv_align_scale_y = 1 / align_scale_y;
-
  last_image = NULL;
  for (i = 0; i < num_glyphs; i++)
    {
      GskGpuImage *image;
      graphene_rect_t glyph_bounds;
-      graphene_point_t glyph_offset, glyph_origin;
-      GskGpuGlyphLookupFlags flags;
-
-      glyph_origin = GRAPHENE_POINT_INIT (offset.x + glyphs[i].geometry.x_offset * inv_pango_scale,
-                                          offset.y + glyphs[i].geometry.y_offset * inv_pango_scale);
-
-      glyph_origin.x = floorf (glyph_origin.x * align_scale_x + 0.5f);
-      glyph_origin.y = floorf (glyph_origin.y * align_scale_y + 0.5f);
-      flags = (((int) glyph_origin.x & 3) | (((int) glyph_origin.y & 3) << 2)) & flags_mask;
-      glyph_origin.x *= inv_align_scale_x;
-      glyph_origin.y *= inv_align_scale_y;
+      graphene_point_t glyph_offset;

      image = gsk_gpu_device_lookup_glyph_image (device,
                                                 self->frame,
                                                 font,
                                                 glyphs[i].glyph,
-                                                 flags,
+                                                 0,
                                                 scale,
                                                 &glyph_bounds,
-                                                 &glyph_offset);
+                                                 &glyph_offset,
+                                                 &scaled_font);

      if (image != last_image)
        {
          if (!gsk_gpu_pattern_writer_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT, &tex_id))
-            return FALSE;
+            break;

          last_image = image;
        }

-      glyph_origin = GRAPHENE_POINT_INIT (glyph_origin.x - glyph_offset.x * inv_scale,
-                                          glyph_origin.y - glyph_offset.y * inv_scale);
+      glyph_offset = GRAPHENE_POINT_INIT (offset.x - glyph_offset.x * inv_scale + (float) glyphs[i].geometry.x_offset / PANGO_SCALE,
+                                          offset.y - glyph_offset.y * inv_scale + (float) glyphs[i].geometry.y_offset / PANGO_SCALE);

      gsk_gpu_pattern_writer_append_uint (self, tex_id);
      gsk_gpu_pattern_writer_append_rect (self,
@@ -3205,7 +3168,7 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
                                              glyph_bounds.size.width * inv_scale,
                                              glyph_bounds.size.height * inv_scale
                                          ),
-                                          &glyph_origin);
+                                          &glyph_offset);
      gsk_gpu_pattern_writer_append_rect (self,
                                          &GRAPHENE_RECT_INIT (
                                              - glyph_bounds.origin.x * inv_scale,
@@ -3213,12 +3176,14 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
                                              gsk_gpu_image_get_width (image) * inv_scale,
                                              gsk_gpu_image_get_height (image) * inv_scale
                                          ),
-                                          &glyph_origin);
+                                          &glyph_offset);

-      offset.x += glyphs[i].geometry.width * inv_pango_scale;
+      offset.x += (float) glyphs[i].geometry.width / PANGO_SCALE;
    }

-  return TRUE;
+  g_clear_object (&scaled_font);
+
+  return i == num_glyphs;
 }

 static gboolean
@@ -19,15 +19,23 @@ struct _GskGpuRadialGradientOp
 };

 static void
-gsk_gpu_radial_gradient_op_print_instance (GskGpuShaderOp *shader,
-                                           gpointer        instance_,
-                                           GString        *string)
+gsk_gpu_radial_gradient_op_print (GskGpuOp    *op,
+                                  GskGpuFrame *frame,
+                                  GString     *string,
+                                  guint        indent)
 {
-  GskGpuRadialgradientInstance *instance = (GskGpuRadialgradientInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuRadialgradientInstance *instance;
+
+  instance = (GskGpuRadialgradientInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);

  if (shader->variation & VARIATION_REPEATING)
-    gsk_gpu_print_string (string, "repeating");
+    gsk_gpu_print_op (string, indent, "repeating-radial-gradient");
+  else
+    gsk_gpu_print_op (string, indent, "radial-gradient");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rect (string, instance->rect);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_RADIAL_GRADIENT_OP_CLASS = {
@@ -35,7 +43,7 @@ static const GskGpuShaderOpClass GSK_GPU_RADIAL_GRADIENT_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuRadialGradientOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_radial_gradient_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -46,7 +54,6 @@ static const GskGpuShaderOpClass GSK_GPU_RADIAL_GRADIENT_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_radialgradient_info,
 #endif
-  gsk_gpu_radial_gradient_op_print_instance,
  gsk_gpu_radialgradient_setup_attrib_locations,
  gsk_gpu_radialgradient_setup_vao
 };
@@ -30,6 +30,9 @@ static const GdkDebugKey gsk_gpu_optimization_keys[] = {
  { "blit", GSK_GPU_OPTIMIZE_BLIT, "Use shaders instead of vkCmdBlit()/glBlitFramebuffer()" },
  { "gradients", GSK_GPU_OPTIMIZE_GRADIENTS, "Don't supersample gradients" },
  { "mipmap", GSK_GPU_OPTIMIZE_MIPMAP, "Avoid creating mipmaps" },
+  { "glyph-align", GSK_GPU_OPTIMIZE_GLYPH_ALIGN, "Never align glyphs to the subpixel grid" },
+
+  { "gl-baseinstance", GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE, "Assume no ARB/EXT_base_instance support" },
 };

 typedef struct _GskGpuRendererPrivate GskGpuRendererPrivate;
@@ -164,36 +167,24 @@ static GskGpuFrame *
 gsk_gpu_renderer_get_frame (GskGpuRenderer *self)
 {
  GskGpuRendererPrivate *priv = gsk_gpu_renderer_get_instance_private (self);
-  GskGpuFrame *earliest_frame = NULL;
-  gint64 earliest_time = G_MAXINT64;
  guint i;

-  for (i = 0; i < G_N_ELEMENTS (priv->frames); i++)
+  while (TRUE)
    {
-      gint64 timestamp;
-
-      if (priv->frames[i] == NULL)
+      for (i = 0; i < G_N_ELEMENTS (priv->frames); i++)
        {
-          priv->frames[i] = gsk_gpu_renderer_create_frame (self);
-          return priv->frames[i];
+          if (priv->frames[i] == NULL)
+            {
+              priv->frames[i] = gsk_gpu_renderer_create_frame (self);
+              return priv->frames[i];
+            }
+
+          if (!gsk_gpu_frame_is_busy (priv->frames[i]))
+            return priv->frames[i];
        }

-      if (!gsk_gpu_frame_is_busy (priv->frames[i]))
-        return priv->frames[i];
-
-      timestamp = gsk_gpu_frame_get_timestamp (priv->frames[i]);
-      if (timestamp < earliest_time)
-        {
-          earliest_time = timestamp;
-          earliest_frame = priv->frames[i];
-        }
+      GSK_GPU_RENDERER_GET_CLASS (self)->wait (self, priv->frames, GSK_GPU_MAX_FRAMES);
    }
-
-  g_assert (earliest_frame);
-
-  gsk_gpu_frame_wait (earliest_frame);
-
-  return earliest_frame;
 }

 static gboolean
@@ -227,17 +218,31 @@ gsk_gpu_renderer_unrealize (GskRenderer *renderer)
 {
  GskGpuRenderer *self = GSK_GPU_RENDERER (renderer);
  GskGpuRendererPrivate *priv = gsk_gpu_renderer_get_instance_private (self);
-  gsize i;
+  gsize i, j;

  gsk_gpu_renderer_make_current (self);

-  for (i = 0; i < G_N_ELEMENTS (priv->frames); i++)
+  while (TRUE)
    {
-      if (priv->frames[i] == NULL)
+      for (i = 0, j = 0; i < G_N_ELEMENTS (priv->frames); i++)
+        {
+          if (priv->frames[i] == NULL)
+            break;
+          if (gsk_gpu_frame_is_busy (priv->frames[i]))
+            {
+              if (i > j)
+                {
+                  priv->frames[j] = priv->frames[i];
+                  priv->frames[i] = NULL;
+                }
+              j++;
+              continue;
+            }
+          g_clear_object (&priv->frames[i]);
+        }
+      if (j == 0)
        break;
-      if (gsk_gpu_frame_is_busy (priv->frames[i]))
-        gsk_gpu_frame_wait (priv->frames[i]);
-      g_clear_object (&priv->frames[i]);
+      GSK_GPU_RENDERER_GET_CLASS (self)->wait (self, priv->frames, j);
    }

  g_clear_object (&priv->context);
@@ -453,7 +458,7 @@ gsk_gpu_renderer_class_init (GskGpuRendererClass *klass)
  gsk_ensure_resources ();

  klass->optimizations = -1;
-  klass->optimizations &= ~gdk_parse_debug_var ("GSK_GPU_DISABLE",
+  klass->optimizations &= ~gdk_parse_debug_var ("GSK_GPU_SKIP",
                                                gsk_gpu_optimization_keys,
                                                G_N_ELEMENTS (gsk_gpu_optimization_keys));
  klass->get_scale = gsk_gpu_renderer_real_get_scale;
@@ -35,6 +35,9 @@ struct _GskGpuRendererClass

  void                  (* make_current)                                (GskGpuRenderer         *self);
  GskGpuImage *         (* get_backbuffer)                              (GskGpuRenderer         *self);
+  void                  (* wait)                                        (GskGpuRenderer         *self,
+                                                                         GskGpuFrame           **frame,
+                                                                         gsize                   n_frames);

  double                (* get_scale)                                   (GskGpuRenderer         *self);
  GdkDmabufFormats *    (* get_dmabuf_formats)                          (GskGpuRenderer         *self);
@@ -17,14 +17,21 @@ struct _GskGpuRoundedColorOp
 };

 static void
-gsk_gpu_rounded_color_op_print_instance (GskGpuShaderOp *shader,
-                                         gpointer        instance_,
-                                         GString        *string)
+gsk_gpu_rounded_color_op_print (GskGpuOp    *op,
+                                GskGpuFrame *frame,
+                                GString     *string,
+                                guint        indent)
 {
-  GskGpuRoundedcolorInstance *instance = (GskGpuRoundedcolorInstance *) instance_;
+  GskGpuShaderOp *shader = (GskGpuShaderOp *) op;
+  GskGpuRoundedcolorInstance *instance;

+  instance = (GskGpuRoundedcolorInstance *) gsk_gpu_frame_get_vertex_data (frame, shader->vertex_offset);
+
+  gsk_gpu_print_op (string, indent, "rounded-color");
+  gsk_gpu_print_shader_info (string, shader->clip);
  gsk_gpu_print_rounded_rect (string, instance->outline);
  gsk_gpu_print_rgba (string, instance->color);
+  gsk_gpu_print_newline (string);
 }

 static const GskGpuShaderOpClass GSK_GPU_ROUNDED_COLOR_OP_CLASS = {
@@ -32,7 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_ROUNDED_COLOR_OP_CLASS = {
    GSK_GPU_OP_SIZE (GskGpuRoundedColorOp),
    GSK_GPU_STAGE_SHADER,
    gsk_gpu_shader_op_finish,
-    gsk_gpu_shader_op_print,
+    gsk_gpu_rounded_color_op_print,
 #ifdef GDK_RENDERING_VULKAN
    gsk_gpu_shader_op_vk_command,
 #endif
@@ -43,7 +50,6 @@ static const GskGpuShaderOpClass GSK_GPU_ROUNDED_COLOR_OP_CLASS = {
 #ifdef GDK_RENDERING_VULKAN
  &gsk_gpu_roundedcolor_info,
 #endif
-  gsk_gpu_rounded_color_op_print_instance,
  gsk_gpu_roundedcolor_setup_attrib_locations,
  gsk_gpu_roundedcolor_setup_vao
 };
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Matthias Clasen	c476c45007	gsk: Maintain clip info for glyph nodes We can determine once whether we are contained, instead of doing it again for every glyph. The performance impact of this is hard to measure.	2024-02-25 18:26:00 -05:00
Matthias Clasen	5d05270ca7	gsk: Don't add images needlessly Most likely, the image for all glyphs will be the same atlas, so check first before calling the add_image function, which will loop over all images. This matches what the pattern code does for glyph nodes. The performance impact of this is hard to measure.	2024-02-25 18:25:42 -05:00
Matthias Clasen	34fb85afd1	gsk: Split the glyph cache Do the glyph cache lookup in two steps: First find a cache for the given font+scale, then look up the glyph+flags. Since font+scale change much less frequently (in particular, they are the same for all glyphs in a text node), it makes sense to keep the result of the last lookup around and check if it still fits. Here are changes in running widget-factory with no-vsync: before after gsk_gpu_device_lookup_glyph_image 1.43% 1.02% g_hash_table_lookup 0.76% 0.43% gsk_gpu_cached_glyph_equal 0.28% 0.21%	2024-02-25 13:47:32 -05:00
Matthias Clasen	05bc4a86c7	gsk: Keep scaled fonts around Create the scaled font on demand, only when we need to render a glyph, and keep it around while processing the remaining glyphs in the text node, rather than recreating it over and over.	2024-02-25 09:35:56 -05:00
Matthias Clasen	93302cc42d	gsk: Stop passing scale to glyph upload op It is always 1.0 now, so there is no point. Instead of the scale, print the font when doing verbose logging.	2024-02-25 09:35:56 -05:00
Matthias Clasen	976f45e614	gsk: Use a scaled font for glyph rendering This changes the approach we take to rendering glyphs in the presence of a scale transform: Instead of scaling the extents and rendering to an image surface with device scale, simply create a scaled font and use it for extents and rendering. This avoids clipping problems with scaling of extents in the presence of hinting.	2024-02-25 09:35:56 -05:00
Matthias Clasen	befccc943a	gsk: Add a way to get a scaled font Add a function to change the size of a font while keeping everything else the same. We use pango api for this if available.	2024-02-25 09:35:55 -05:00