gtk/textview: defer GtkTextLineDisplay finalization

Defer the finalization of our GtkTextLineDisplay until we've completed
processing the current frame. Otherwise we risk doing additional work that
could cause us to miss our frame deadline.

gdk/gdkarrayimpl.c

@@ -52,6 +52,13 @@ G_BEGIN_DECLS
 #define gdk_array_paste(GDK_ARRAY_NAME, func_name) gdk_array_paste_more (GDK_ARRAY_NAME, func_name)
 #define gdk_array(func_name) gdk_array_paste (GDK_ARRAY_NAME, func_name)
 
+#if !defined(INCLUDE_DECL) && !defined(INCLUDE_IMPL)
+#define INCLUDE_DECL 1
+#define INCLUDE_IMPL 1
+#endif
+
+#ifdef INCLUDE_DECL
+
 typedef struct GdkArray GdkArray;
 
 struct GdkArray
@@ -82,6 +89,9 @@ gdk_array(init) (GdkArray *self)
 #endif
 }
 
+#endif /* INCLUDE_DECL */
+#ifdef INCLUDE_IMPL
+
 G_GNUC_UNUSED static inline gsize
 gdk_array(get_capacity) (const GdkArray *self)
 {
@@ -304,6 +314,8 @@ gdk_array(get) (const GdkArray *self,
  }
 #endif
 
+#endif  /* INCLUDE_IMPL */
+
 #ifndef GDK_ARRAY_NO_UNDEF
 
 #undef _T_
@@ -321,6 +333,9 @@ gdk_array(get) (const GdkArray *self,
 #undef GDK_ARRAY_PREALLOC
 #undef GDK_ARRAY_TYPE_NAME
 #undef GDK_ARRAY_NO_MEMSET
+
+#undef INCLUDE_DECL
+#undef INCLUDE_IMPL
 #endif
 
 G_END_DECLS

gsk/gpu/gskglbuffer.c

@@ -11,7 +11,6 @@ struct _GskGLBuffer
   GLenum target;
   GLuint buffer_id;
   GLenum access;
-  guchar *data;
 };
 
 G_DEFINE_TYPE (GskGLBuffer, gsk_gl_buffer, GSK_TYPE_GPU_BUFFER)
@@ -24,7 +23,6 @@ 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);
@@ -35,7 +33,9 @@ gsk_gl_buffer_map (GskGpuBuffer *buffer)
 {
   GskGLBuffer *self = GSK_GL_BUFFER (buffer);
 
-  return self->data;
+  gsk_gl_buffer_bind (self);
+
+  return glMapBuffer (self->target, self->access);
 }
 
 static void
@@ -44,14 +44,12 @@ gsk_gl_buffer_unmap (GskGpuBuffer *buffer,
 {
   GskGLBuffer *self = GSK_GL_BUFFER (buffer);
 
-  if (used == 0)
-    return;
-
   gsk_gl_buffer_bind (self);
 
   profiler_buffer_uploads += used;
-  glBufferSubData (self->target, 0, used, self->data);
   gdk_profiler_set_int_counter (profiler_buffer_uploads_id, profiler_buffer_uploads);
+
+  glUnmapBuffer (self->target);
 }
 
 static void
@@ -90,7 +88,6 @@ gsk_gl_buffer_new (GLenum target,
   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);
 }

gsk/gpu/gskgldescriptors.c

@@ -5,24 +5,14 @@
 #include "gskglbufferprivate.h"
 #include "gskglimageprivate.h"
 
-struct _GskGLDescriptors
-{
-  GskGpuDescriptors parent_instance;
-
-  GskGLDevice *device;
-  guint n_external;
-};
-
-G_DEFINE_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK_TYPE_GPU_DESCRIPTORS)
-
 static void
-gsk_gl_descriptors_finalize (GObject *object)
+gsk_gl_descriptors_finalize (GskGpuDescriptors *desc)
 {
-  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (object);
+  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (desc);
 
   g_object_unref (self->device);
 
-  G_OBJECT_CLASS (gsk_gl_descriptors_parent_class)->finalize (object);
+  gsk_gpu_descriptors_finalize (&self->parent_instance);
 }
 
 static gboolean
@@ -72,29 +62,25 @@ gsk_gl_descriptors_add_buffer (GskGpuDescriptors *desc,
   return TRUE;
 }
 
-static void
-gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass)
+static GskGpuDescriptorsClass GSK_GL_DESCRIPTORS_CLASS =
 {
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_gl_descriptors_finalize;
-
-  descriptors_class->add_image = gsk_gl_descriptors_add_image;
-  descriptors_class->add_buffer = gsk_gl_descriptors_add_buffer;
-}
-
-static void
-gsk_gl_descriptors_init (GskGLDescriptors *self)
-{
-}
+  .finalize = gsk_gl_descriptors_finalize,
+  .add_image = gsk_gl_descriptors_add_image,
+  .add_buffer = gsk_gl_descriptors_add_buffer,
+};
 
 GskGpuDescriptors *
 gsk_gl_descriptors_new (GskGLDevice *device)
 {
   GskGLDescriptors *self;
+  GskGpuDescriptors *desc;
 
-  self = g_object_new (GSK_TYPE_GL_DESCRIPTORS, NULL);
+  self = g_new0 (GskGLDescriptors, 1);
+  desc = GSK_GPU_DESCRIPTORS (self);
+
+  desc->ref_count = 1;
+  desc->desc_class = (GskGpuDescriptorsClass *) &GSK_GL_DESCRIPTORS_CLASS;
+  gsk_gpu_descriptors_init (&self->parent_instance);
 
   self->device = g_object_ref (device);
 
@@ -110,7 +96,7 @@ gsk_gl_descriptors_get_n_external (GskGLDescriptors *self)
 void
 gsk_gl_descriptors_use (GskGLDescriptors *self)
 {
-  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
+  GskGpuDescriptors *desc = &self->parent_instance;
   gsize i, ext, n_textures;
 
   n_textures = 16 - 3 * self->n_external;

gsk/gpu/gskgldescriptorsprivate.h

@@ -6,9 +6,17 @@
 
 G_BEGIN_DECLS
 
-#define GSK_TYPE_GL_DESCRIPTORS (gsk_gl_descriptors_get_type ())
+typedef struct _GskGLDescriptors GskGLDescriptors;
 
-G_DECLARE_FINAL_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK, GL_DESCRIPTORS, GskGpuDescriptors)
+#define GSK_GL_DESCRIPTORS(d) ((GskGLDescriptors *) (d))
+
+struct _GskGLDescriptors
+{
+  GskGpuDescriptors parent_instance;
+
+  GskGLDevice *device;
+  guint n_external;
+};
 
 GskGpuDescriptors *               gsk_gl_descriptors_new                (GskGLDevice            *device);
 

gsk/gpu/gskgpudescriptors.c

@@ -2,22 +2,6 @@
 
 #include "gskgpudescriptorsprivate.h"
 
-typedef struct _GskGpuImageEntry GskGpuImageEntry;
-typedef struct _GskGpuBufferEntry GskGpuBufferEntry;
-
-struct _GskGpuImageEntry
-{
-  GskGpuImage *image;
-  GskGpuSampler sampler;
-  guint32 descriptor;
-};
-
-struct _GskGpuBufferEntry
-{
-  GskGpuBuffer *buffer;
-  guint32 descriptor;
-};
-
 static void
 gsk_gpu_image_entry_clear (gpointer data)
 {
@@ -34,6 +18,8 @@ gsk_gpu_buffer_entry_clear (gpointer data)
   g_object_unref (entry->buffer);
 }
 
+#define INCLUDE_IMPL 1
+
 #define GDK_ARRAY_NAME gsk_gpu_image_entries
 #define GDK_ARRAY_TYPE_NAME GskGpuImageEntries
 #define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry
@@ -43,6 +29,8 @@ gsk_gpu_buffer_entry_clear (gpointer data)
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
+#define INCLUDE_IMPL 1
+
 #define GDK_ARRAY_NAME gsk_gpu_buffer_entries
 #define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries
 #define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry
@@ -52,80 +40,48 @@ gsk_gpu_buffer_entry_clear (gpointer data)
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate;
-
-struct _GskGpuDescriptorsPrivate
+void
+gsk_gpu_descriptors_finalize (GskGpuDescriptors *self)
 {
-  GskGpuImageEntries images;
-  GskGpuBufferEntries buffers;
-};
-
-G_DEFINE_TYPE_WITH_PRIVATE (GskGpuDescriptors, gsk_gpu_descriptors, G_TYPE_OBJECT)
-
-static void
-gsk_gpu_descriptors_finalize (GObject *object)
-{
-  GskGpuDescriptors *self = GSK_GPU_DESCRIPTORS (object);
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  gsk_gpu_image_entries_clear (&priv->images);
-  gsk_gpu_buffer_entries_clear (&priv->buffers);
-
-  G_OBJECT_CLASS (gsk_gpu_descriptors_parent_class)->finalize (object);
+  gsk_gpu_image_entries_clear (&self->images);
+  gsk_gpu_buffer_entries_clear (&self->buffers);
 }
 
-static void
-gsk_gpu_descriptors_class_init (GskGpuDescriptorsClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_gpu_descriptors_finalize;
-}
-
-static void
+void
 gsk_gpu_descriptors_init (GskGpuDescriptors *self)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  gsk_gpu_image_entries_init (&priv->images);
-  gsk_gpu_buffer_entries_init (&priv->buffers);
+  gsk_gpu_image_entries_init (&self->images);
+  gsk_gpu_buffer_entries_init (&self->buffers);
 }
 
 gsize
 gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  return gsk_gpu_image_entries_get_size (&priv->images);
+  return gsk_gpu_image_entries_get_size (&self->images);
 }
 
 gsize
 gsk_gpu_descriptors_get_n_buffers (GskGpuDescriptors *self)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  return gsk_gpu_buffer_entries_get_size (&priv->buffers);
+  return gsk_gpu_buffer_entries_get_size (&self->buffers);
 }
 void
 gsk_gpu_descriptors_set_size (GskGpuDescriptors *self,
                               gsize              n_images,
                               gsize              n_buffers)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
+  g_assert (n_images <= gsk_gpu_image_entries_get_size (&self->images));
+  gsk_gpu_image_entries_set_size (&self->images, n_images);
 
-  g_assert (n_images <= gsk_gpu_image_entries_get_size (&priv->images));
-  gsk_gpu_image_entries_set_size (&priv->images, n_images);
-
-  g_assert (n_buffers <= gsk_gpu_buffer_entries_get_size (&priv->buffers));
-  gsk_gpu_buffer_entries_set_size (&priv->buffers, n_buffers);
+  g_assert (n_buffers <= gsk_gpu_buffer_entries_get_size (&self->buffers));
+  gsk_gpu_buffer_entries_set_size (&self->buffers, n_buffers);
 }
 
 GskGpuImage *
 gsk_gpu_descriptors_get_image (GskGpuDescriptors *self,
                                gsize              id)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id);
+  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, id);
 
   return entry->image;
 }
@@ -134,8 +90,7 @@ GskGpuSampler
 gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self,
                                  gsize              id)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id);
+  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, id);
 
   return entry->sampler;
 }
@@ -144,12 +99,11 @@ gsize
 gsk_gpu_descriptors_find_image (GskGpuDescriptors *self,
                                 guint32            descriptor)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
   gsize i;
 
-  for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++)
+  for (i = 0; i < gsk_gpu_image_entries_get_size (&self->images); i++)
     {
-      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i);
+      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, i);
 
       if (entry->descriptor == descriptor)
         return i;
@@ -162,8 +116,7 @@ GskGpuBuffer *
 gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self,
                                gsize              id)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, id);
+  const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&self->buffers, id);
 
   return entry->buffer;
 }
@@ -174,13 +127,12 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
                                GskGpuSampler      sampler,
                                guint32           *out_descriptor)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
   gsize i;
   guint32 descriptor;
 
-  for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++)
+  for (i = 0; i < gsk_gpu_image_entries_get_size (&self->images); i++)
     {
-      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i);
+      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, i);
 
       if (entry->image == image && entry->sampler == sampler)
         {
@@ -189,10 +141,10 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
         }
     }
 
-  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_image (self, image, sampler, &descriptor))
+  if (!self->desc_class->add_image (self, image, sampler, &descriptor))
     return FALSE;
 
-  gsk_gpu_image_entries_append (&priv->images,
+  gsk_gpu_image_entries_append (&self->images,
                                 &(GskGpuImageEntry) {
                                      .image = g_object_ref (image),
                                      .sampler = sampler,
@@ -209,13 +161,12 @@ gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
                                 GskGpuBuffer      *buffer,
                                 guint32           *out_descriptor)
 {
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
   gsize i;
   guint32 descriptor;
 
-  for (i = 0; i < gsk_gpu_buffer_entries_get_size (&priv->buffers); i++)
+  for (i = 0; i < gsk_gpu_buffer_entries_get_size (&self->buffers); i++)
     {
-      const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, i);
+      const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&self->buffers, i);
 
       if (entry->buffer == buffer)
         {
@@ -224,10 +175,10 @@ gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
         }
     }
 
-  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_buffer (self, buffer, &descriptor))
+  if (!self->desc_class->add_buffer (self, buffer, &descriptor))
     return FALSE;
 
-  gsk_gpu_buffer_entries_append (&priv->buffers,
+  gsk_gpu_buffer_entries_append (&self->buffers,
                                  &(GskGpuBufferEntry) {
                                       .buffer = g_object_ref (buffer),
                                       .descriptor = descriptor
@@ -238,3 +189,22 @@ gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
   return TRUE;
 }
 
+GskGpuDescriptors *
+gsk_gpu_descriptors_ref (GskGpuDescriptors *self)
+{
+  self->ref_count++;
+
+  return self;
+}
+
+void
+gsk_gpu_descriptors_unref (GskGpuDescriptors *self)
+{
+  self->ref_count--;
+
+  if (self->ref_count == 0)
+    {
+      self->desc_class->finalize (self);
+      g_free (self);
+    }
+}

gsk/gpu/gskgpudescriptorsprivate.h

@@ -2,26 +2,62 @@
 
 #include "gskgputypesprivate.h"
 
+typedef struct _GskGpuImageEntry GskGpuImageEntry;
+typedef struct _GskGpuBufferEntry GskGpuBufferEntry;
+
+struct _GskGpuImageEntry
+{
+  GskGpuImage *image;
+  GskGpuSampler sampler;
+  guint32 descriptor;
+};
+
+struct _GskGpuBufferEntry
+{
+  GskGpuBuffer *buffer;
+  guint32 descriptor;
+};
+
+#define INCLUDE_DECL 1
+
+#define GDK_ARRAY_NAME gsk_gpu_image_entries
+#define GDK_ARRAY_TYPE_NAME GskGpuImageEntries
+#define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry
+#define GDK_ARRAY_BY_VALUE 1
+#define GDK_ARRAY_PREALLOC 16
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+#define INCLUDE_DECL 1
+
+#define GDK_ARRAY_NAME gsk_gpu_buffer_entries
+#define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries
+#define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry
+#define GDK_ARRAY_BY_VALUE 1
+#define GDK_ARRAY_PREALLOC 4
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
 G_BEGIN_DECLS
 
-#define GSK_TYPE_GPU_DESCRIPTORS         (gsk_gpu_descriptors_get_type ())
-#define GSK_GPU_DESCRIPTORS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptors))
-#define GSK_GPU_DESCRIPTORS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptorsClass))
-#define GSK_IS_GPU_DESCRIPTORS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSK_TYPE_GPU_DESCRIPTORS))
-#define GSK_IS_GPU_DESCRIPTORS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GSK_TYPE_GPU_DESCRIPTORS))
-#define GSK_GPU_DESCRIPTORS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptorsClass))
-
+typedef struct _GskGpuDescriptors GskGpuDescriptors;
 typedef struct _GskGpuDescriptorsClass GskGpuDescriptorsClass;
 
+#define GSK_GPU_DESCRIPTORS(d) ((GskGpuDescriptors *) (d))
+
 struct _GskGpuDescriptors
 {
-  GObject parent_instance;
+  GskGpuDescriptorsClass *desc_class;
+
+  int ref_count;
+
+  GskGpuImageEntries images;
+  GskGpuBufferEntries buffers;
 };
 
 struct _GskGpuDescriptorsClass
 {
-  GObjectClass parent_class;
-
+  void                  (* finalize)                                    (GskGpuDescriptors      *self);
   gboolean              (* add_image)                                   (GskGpuDescriptors      *self,
                                                                          GskGpuImage            *image,
                                                                          GskGpuSampler           sampler,
@@ -31,7 +67,9 @@ struct _GskGpuDescriptorsClass
                                                                          guint32                *out_id);
 };
 
-GType                   gsk_gpu_descriptors_get_type                    (void) G_GNUC_CONST;
+GskGpuDescriptors *     gsk_gpu_descriptors_ref                         (GskGpuDescriptors      *self);
+void                    gsk_gpu_descriptors_unref                       (GskGpuDescriptors      *self);
+
 
 gsize                   gsk_gpu_descriptors_get_n_images                (GskGpuDescriptors      *self);
 gsize                   gsk_gpu_descriptors_get_n_buffers               (GskGpuDescriptors      *self);
@@ -55,7 +93,7 @@ gboolean                gsk_gpu_descriptors_add_buffer                  (GskGpuD
                                                                          GskGpuBuffer           *buffer,
                                                                          guint32                *out_descriptor);
 
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref)
+void gsk_gpu_descriptors_finalize (GskGpuDescriptors *self);
+void gsk_gpu_descriptors_init     (GskGpuDescriptors *self);
 
 G_END_DECLS

gsk/gpu/gskgpudevice.c

@@ -33,6 +33,15 @@ typedef struct _GskGpuCachedGlyph GskGpuCachedGlyph;
 typedef struct _GskGpuCachedTexture GskGpuCachedTexture;
 typedef struct _GskGpuDevicePrivate GskGpuDevicePrivate;
 
+typedef struct _GlyphKey GlyphKey;
+struct _GlyphKey
+{
+  PangoFont *font;
+  PangoGlyph glyph;
+  GskGpuGlyphLookupFlags flags;
+  float scale;
+};
+
 struct _GskGpuDevicePrivate
 {
   GdkDisplay *display;
@@ -49,6 +58,11 @@ struct _GskGpuDevicePrivate
   GskGpuCachedAtlas *current_atlas;
 
   /* atomic */ gsize dead_texture_pixels;
+
+  struct {
+    GlyphKey key;
+    GskGpuCachedGlyph *value;
+  } front[256];
 };
 
 G_DEFINE_TYPE_WITH_PRIVATE (GskGpuDevice, gsk_gpu_device, G_TYPE_OBJECT)
@@ -361,10 +375,7 @@ struct _GskGpuCachedGlyph
 {
   GskGpuCached parent;
 
-  PangoFont *font;
-  PangoGlyph glyph;
-  GskGpuGlyphLookupFlags flags;
-  float scale;
+  GlyphKey key;
 
   GskGpuImage *image;
   graphene_rect_t bounds;
@@ -380,7 +391,7 @@ gsk_gpu_cached_glyph_free (GskGpuDevice *device,
 
   g_hash_table_remove (priv->glyph_cache, self);
 
-  g_object_unref (self->font);
+  g_object_unref (self->key.font);
   g_object_unref (self->image);
 
   g_free (self);
@@ -408,10 +419,10 @@ gsk_gpu_cached_glyph_hash (gconstpointer data)
 {
   const GskGpuCachedGlyph *glyph = data;
 
-  return GPOINTER_TO_UINT (glyph->font) ^
-         glyph->glyph ^
-         (glyph->flags << 24) ^
-         ((guint) glyph->scale * PANGO_SCALE);
+  return GPOINTER_TO_UINT (glyph->key.font) ^
+         glyph->key.glyph ^
+         (glyph->key.flags << 24) ^
+         ((guint) glyph->key.scale * PANGO_SCALE);
 }
 
 static gboolean
@@ -421,10 +432,10 @@ gsk_gpu_cached_glyph_equal (gconstpointer v1,
   const GskGpuCachedGlyph *glyph1 = v1;
   const GskGpuCachedGlyph *glyph2 = v2;
 
-  return glyph1->font == glyph2->font
-      && glyph1->glyph == glyph2->glyph
-      && glyph1->flags == glyph2->flags
-      && glyph1->scale == glyph2->scale;
+  return glyph1->key.font == glyph2->key.font
+      && glyph1->key.glyph == glyph2->key.glyph
+      && glyph1->key.flags == glyph2->key.flags
+      && glyph1->key.scale == glyph2->key.scale;
 }
 
 static const GskGpuCachedClass GSK_GPU_CACHED_GLYPH_CLASS =
@@ -894,10 +905,10 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
 {
   GskGpuDevicePrivate *priv = gsk_gpu_device_get_instance_private (self);
   GskGpuCachedGlyph lookup = {
-    .font = font,
-    .glyph = glyph,
-    .flags = flags,
-    .scale = scale
+    .key.font = font,
+    .key.glyph = glyph,
+    .key.flags = flags,
+    .key.scale = scale
   };
   GskGpuCachedGlyph *cache;
   PangoRectangle ink_rect;
@@ -907,14 +918,32 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
   gsize atlas_x, atlas_y, padding;
   float subpixel_x, subpixel_y;
   PangoFont *scaled_font;
+  guint64 timestamp = gsk_gpu_frame_get_timestamp (frame);
+  guint front_index = glyph & 0xFF;
+
+  if (memcmp (&lookup.key, &priv->front[front_index], sizeof (GlyphKey)) == 0)
+    {
+      cache = priv->front[front_index].value;
+
+      gsk_gpu_cached_use (self, (GskGpuCached *) cache, timestamp);
+
+      *out_bounds = cache->bounds;
+      *out_origin = cache->origin;
+
+      return cache->image;
+    }
 
   cache = g_hash_table_lookup (priv->glyph_cache, &lookup);
   if (cache)
     {
-      gsk_gpu_cached_use (self, (GskGpuCached *) cache, gsk_gpu_frame_get_timestamp (frame));
+      memcpy (&priv->front[front_index].key, &lookup.key, sizeof (GlyphKey));
+      priv->front[front_index].value = cache;
+
+      gsk_gpu_cached_use (self, (GskGpuCached *) cache, timestamp);
 
       *out_bounds = cache->bounds;
       *out_origin = cache->origin;
+
       return cache->image;
     }
 
@@ -947,10 +976,10 @@ 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->key.font = g_object_ref (font);
+  cache->key.glyph = glyph;
+  cache->key.flags = flags;
+  cache->key.scale = scale;
   cache->bounds = rect;
   cache->image = image;
   cache->origin = GRAPHENE_POINT_INIT (- origin.x + subpixel_x,
@@ -971,7 +1000,10 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
                                                  cache->origin.y + padding));
 
   g_hash_table_insert (priv->glyph_cache, cache, cache);
-  gsk_gpu_cached_use (self, (GskGpuCached *) cache, gsk_gpu_frame_get_timestamp (frame));
+  gsk_gpu_cached_use (self, (GskGpuCached *) cache, timestamp);
+
+  memcpy (&priv->front[front_index].key, &lookup.key, sizeof (GlyphKey));
+  priv->front[front_index].value = cache;
 
   *out_bounds = cache->bounds;
   *out_origin = cache->origin;

gsk/gpu/gskgpunodeprocessor.c

@@ -152,7 +152,7 @@ static void
 gsk_gpu_node_processor_finish (GskGpuNodeProcessor *self)
 {
   g_clear_pointer (&self->modelview, gsk_transform_unref);
-  g_clear_object (&self->desc);
+  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
 }
 
 static void
@@ -170,7 +170,7 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
 
   self->frame = frame;
   if (desc)
-    self->desc = g_object_ref (desc);
+    self->desc = gsk_gpu_descriptors_ref (desc);
   else
     self->desc = NULL;
 
@@ -268,7 +268,7 @@ gsk_gpu_node_processor_add_image (GskGpuNodeProcessor *self,
       if (gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor))
         return descriptor;
 
-      g_object_unref (self->desc);
+      gsk_gpu_descriptors_unref (self->desc);
     }
 
   self->desc = gsk_gpu_frame_create_descriptors (self->frame);
@@ -545,7 +545,7 @@ gsk_gpu_pattern_writer_finish (GskGpuPatternWriter *self)
 {
   pattern_buffer_clear (&self->buffer);
   g_assert (self->stack == 0);
-  g_clear_object (&self->desc);
+  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
 }
 
 static gboolean

gsk/gpu/gskgpushaderop.c

@@ -23,7 +23,7 @@ gsk_gpu_shader_op_finish (GskGpuOp *op)
 {
   GskGpuShaderOp *self = (GskGpuShaderOp *) op;
 
-  g_clear_object (&self->desc);
+  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
 }
 
 #ifdef GDK_RENDERING_VULKAN
@@ -197,7 +197,7 @@ gsk_gpu_shader_op_alloc (GskGpuFrame               *frame,
   self->variation = variation;
   self->clip = clip;
   if (desc)
-    self->desc = g_object_ref (desc);
+    self->desc = gsk_gpu_descriptors_ref (desc);
   else
     self->desc = NULL;
   self->vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, op_class->vertex_size);

gsk/gpu/gskvulkandescriptors.c

@@ -6,22 +6,13 @@
 #include "gskvulkanframeprivate.h"
 #include "gskvulkanimageprivate.h"
 
-G_DEFINE_TYPE (GskVulkanDescriptors, gsk_vulkan_descriptors, GSK_TYPE_GPU_DESCRIPTORS)
-
-static void
-gsk_vulkan_descriptors_class_init (GskVulkanDescriptorsClass *klass)
-{
-}
-
-static void
-gsk_vulkan_descriptors_init (GskVulkanDescriptors *self)
-{
-}
-
 GskVulkanPipelineLayout *
 gsk_vulkan_descriptors_get_pipeline_layout (GskVulkanDescriptors *self)
 {
-  return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->get_pipeline_layout (self);
+  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
+  GskVulkanDescriptorsClass *class = GSK_VULKAN_DESCRIPTORS_CLASS (desc->desc_class);
+
+  return class->get_pipeline_layout (self);
 }
 
 void
@@ -48,5 +39,20 @@ gsk_vulkan_descriptors_bind (GskVulkanDescriptors *self,
                              GskVulkanDescriptors *previous,
                              VkCommandBuffer       vk_command_buffer)
 {
-  return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->bind (self, previous, vk_command_buffer);
+  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
+  GskVulkanDescriptorsClass *class = GSK_VULKAN_DESCRIPTORS_CLASS (desc->desc_class);
+
+  return class->bind (self, previous, vk_command_buffer);
+}
+
+void
+gsk_vulkan_descriptors_init (GskVulkanDescriptors *self)
+{
+  gsk_gpu_descriptors_init ((GskGpuDescriptors *) self);
+}
+
+void
+gsk_vulkan_descriptors_finalize (GskVulkanDescriptors *self)
+{
+  gsk_gpu_descriptors_finalize ((GskGpuDescriptors *) self);
 }

gsk/gpu/gskvulkandescriptorsprivate.h

@@ -6,15 +6,12 @@
 
 G_BEGIN_DECLS
 
-#define GSK_TYPE_VULKAN_DESCRIPTORS         (gsk_vulkan_descriptors_get_type ())
-#define GSK_VULKAN_DESCRIPTORS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptors))
-#define GSK_VULKAN_DESCRIPTORS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptorsClass))
-#define GSK_IS_VULKAN_DESCRIPTORS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSK_TYPE_VULKAN_DESCRIPTORS))
-#define GSK_IS_VULKAN_DESCRIPTORS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GSK_TYPE_VULKAN_DESCRIPTORS))
-#define GSK_VULKAN_DESCRIPTORS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptorsClass))
-
+typedef struct _GskVulkanDescriptors GskVulkanDescriptors;
 typedef struct _GskVulkanDescriptorsClass GskVulkanDescriptorsClass;
 
+#define GSK_VULKAN_DESCRIPTORS(d) ((GskVulkanDescriptors *) (d))
+#define GSK_VULKAN_DESCRIPTORS_CLASS(d) ((GskVulkanDescriptorsClass *) (d))
+
 struct _GskVulkanDescriptors
 {
   GskGpuDescriptors parent_instance;
@@ -30,8 +27,6 @@ struct _GskVulkanDescriptorsClass
                                                                                  VkCommandBuffer         vk_command_buffer);
 };
 
-GType                           gsk_vulkan_descriptors_get_type                 (void) G_GNUC_CONST;
-
 GskVulkanPipelineLayout *       gsk_vulkan_descriptors_get_pipeline_layout      (GskVulkanDescriptors   *self);
 
 void                            gsk_vulkan_descriptors_transition               (GskVulkanDescriptors   *self,
@@ -41,7 +36,8 @@ void                            gsk_vulkan_descriptors_bind
                                                                                  GskVulkanDescriptors   *previous,
                                                                                  VkCommandBuffer         vk_command_buffer);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskVulkanDescriptors, g_object_unref)
+void                            gsk_vulkan_descriptors_init     (GskVulkanDescriptors *self);
+void                            gsk_vulkan_descriptors_finalize (GskVulkanDescriptors *self);
 
 G_END_DECLS
 

gsk/gpu/gskvulkanframe.c

@@ -13,10 +13,16 @@
 #include "gdk/gdkdisplayprivate.h"
 #include "gdk/gdkdmabuftextureprivate.h"
 
+static inline void
+gsk_vulkan_real_descriptors_unref (GskVulkanRealDescriptors *desc)
+{
+  gsk_gpu_descriptors_unref (GSK_GPU_DESCRIPTORS (desc));
+}
+
 #define GDK_ARRAY_NAME gsk_descriptors
 #define GDK_ARRAY_TYPE_NAME GskDescriptors
 #define GDK_ARRAY_ELEMENT_TYPE GskVulkanRealDescriptors *
-#define GDK_ARRAY_FREE_FUNC g_object_unref
+#define GDK_ARRAY_FREE_FUNC gsk_vulkan_real_descriptors_unref
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
@@ -262,7 +268,7 @@ gsk_vulkan_frame_create_descriptors (GskGpuFrame *frame)
       desc = gsk_vulkan_real_descriptors_new (self);
       gsk_descriptors_append (&self->descriptors, desc);
 
-      return GSK_GPU_DESCRIPTORS (g_object_ref (desc));
+      return gsk_gpu_descriptors_ref (GSK_GPU_DESCRIPTORS (desc));
     }
 }
 

gsk/gpu/gskvulkanrealdescriptors.c

@@ -2,9 +2,7 @@
 
 #include "gskvulkanrealdescriptorsprivate.h"
 
-#include "gskvulkanbufferprivate.h"
-#include "gskvulkanframeprivate.h"
-#include "gskvulkanimageprivate.h"
+#define INCLUDE_IMPL 1
 
 #define GDK_ARRAY_NAME gsk_descriptor_image_infos
 #define GDK_ARRAY_TYPE_NAME GskDescriptorImageInfos
@@ -14,6 +12,8 @@
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
+#define INCLUDE_IMPL 1
+
 #define GDK_ARRAY_NAME gsk_descriptor_buffer_infos
 #define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos
 #define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo
@@ -22,6 +22,8 @@
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
+#define INCLUDE_IMPL 1
+
 #define GDK_ARRAY_NAME gsk_samplers
 #define GDK_ARRAY_TYPE_NAME GskSamplers
 #define GDK_ARRAY_ELEMENT_TYPE VkSampler
@@ -29,24 +31,6 @@
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-struct _GskVulkanRealDescriptors
-{
-  GskVulkanDescriptors parent_instance;
-
-  GskVulkanFrame *frame; /* no reference, the frame owns us */
-
-  GskVulkanPipelineLayout *pipeline_layout;
-
-  GskSamplers immutable_samplers;
-  GskDescriptorImageInfos descriptor_immutable_images;
-  GskDescriptorImageInfos descriptor_images;
-  GskDescriptorBufferInfos descriptor_buffers;
-
-  VkDescriptorSet descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS];
-};
-
-G_DEFINE_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS)
-
 static GskVulkanPipelineLayout *
 gsk_vulkan_real_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc)
 {
@@ -154,9 +138,9 @@ gsk_vulkan_real_descriptors_add_buffer (GskGpuDescriptors *desc,
 }
 
 static void
-gsk_vulkan_real_descriptors_finalize (GObject *object)
+gsk_vulkan_real_descriptors_finalize (GskGpuDescriptors *desc)
 {
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (object);
+  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
 
   gsk_samplers_clear (&self->immutable_samplers);
   gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images);
@@ -166,28 +150,25 @@ gsk_vulkan_real_descriptors_finalize (GObject *object)
   gsk_vulkan_device_release_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
                                              self->pipeline_layout);
 
-  G_OBJECT_CLASS (gsk_vulkan_real_descriptors_parent_class)->finalize (object);
+  gsk_vulkan_descriptors_finalize ((GskVulkanDescriptors *) desc);
 }
 
-static void
-gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass)
+static GskVulkanDescriptorsClass GSK_VULKAN_REAL_DESCRIPTORS_CLASS =
 {
-  GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass);
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_vulkan_real_descriptors_finalize;
-
-  descriptors_class->add_image = gsk_vulkan_real_descriptors_add_image;
-  descriptors_class->add_buffer = gsk_vulkan_real_descriptors_add_buffer;
-
-  vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout;
-  vulkan_descriptors_class->bind = gsk_vulkan_real_descriptors_bind;
-}
+  .parent_class = (GskGpuDescriptorsClass) {
+    .finalize = gsk_vulkan_real_descriptors_finalize,
+    .add_image = gsk_vulkan_real_descriptors_add_image,
+    .add_buffer = gsk_vulkan_real_descriptors_add_buffer,
+   },
+  .get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout,
+  .bind = gsk_vulkan_real_descriptors_bind
+};
 
 static void
 gsk_vulkan_real_descriptors_init (GskVulkanRealDescriptors *self)
 {
+  gsk_vulkan_descriptors_init (GSK_VULKAN_DESCRIPTORS (self));
+
   gsk_samplers_init (&self->immutable_samplers);
   gsk_descriptor_image_infos_init (&self->descriptor_immutable_images);
   gsk_descriptor_image_infos_init (&self->descriptor_images);
@@ -198,8 +179,15 @@ GskVulkanRealDescriptors *
 gsk_vulkan_real_descriptors_new (GskVulkanFrame *frame)
 {
   GskVulkanRealDescriptors *self;
+  GskGpuDescriptors *desc;
 
-  self = g_object_new (GSK_TYPE_VULKAN_REAL_DESCRIPTORS, NULL);
+  self = g_new0 (GskVulkanRealDescriptors, 1);
+
+  desc = GSK_GPU_DESCRIPTORS (self);
+  desc->ref_count = 1;
+  desc->desc_class = (GskGpuDescriptorsClass *) &GSK_VULKAN_REAL_DESCRIPTORS_CLASS;
+
+  gsk_vulkan_real_descriptors_init (self);
 
   self->frame = frame;
 

gsk/gpu/gskvulkanrealdescriptorsprivate.h

@@ -3,11 +3,61 @@
 #include "gskvulkandescriptorsprivate.h"
 #include "gskvulkanframeprivate.h"
 
+#include "gskvulkanbufferprivate.h"
+#include "gskvulkanframeprivate.h"
+#include "gskvulkanimageprivate.h"
+
+#define INCLUDE_DECL 1
+
+#define GDK_ARRAY_NAME gsk_descriptor_image_infos
+#define GDK_ARRAY_TYPE_NAME GskDescriptorImageInfos
+#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorImageInfo
+#define GDK_ARRAY_BY_VALUE 1
+#define GDK_ARRAY_PREALLOC 128
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+#define INCLUDE_DECL 1
+
+#define GDK_ARRAY_NAME gsk_descriptor_buffer_infos
+#define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos
+#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo
+#define GDK_ARRAY_BY_VALUE 1
+#define GDK_ARRAY_PREALLOC 32
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+#define INCLUDE_DECL 1
+
+#define GDK_ARRAY_NAME gsk_samplers
+#define GDK_ARRAY_TYPE_NAME GskSamplers
+#define GDK_ARRAY_ELEMENT_TYPE VkSampler
+#define GDK_ARRAY_PREALLOC 32
+#define GDK_ARRAY_NO_MEMSET 1
+#include "gdk/gdkarrayimpl.c"
+
+
 G_BEGIN_DECLS
 
-#define GSK_TYPE_VULKAN_REAL_DESCRIPTORS (gsk_vulkan_real_descriptors_get_type ())
+typedef struct _GskVulkanRealDescriptors GskVulkanRealDescriptors;
 
-G_DECLARE_FINAL_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK, VULKAN_REAL_DESCRIPTORS, GskVulkanDescriptors)
+#define GSK_VULKAN_REAL_DESCRIPTORS(d) ((GskVulkanRealDescriptors *) (d))
+
+struct _GskVulkanRealDescriptors
+{
+  GskVulkanDescriptors parent_instance;
+
+  GskVulkanFrame *frame; /* no reference, the frame owns us */
+
+  GskVulkanPipelineLayout *pipeline_layout;
+
+  GskSamplers immutable_samplers;
+  GskDescriptorImageInfos descriptor_immutable_images;
+  GskDescriptorImageInfos descriptor_images;
+  GskDescriptorBufferInfos descriptor_buffers;
+
+  VkDescriptorSet descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS];
+};
 
 GskVulkanRealDescriptors *      gsk_vulkan_real_descriptors_new                 (GskVulkanFrame                 *frame);
 

gsk/gpu/gskvulkansubdescriptors.c

@@ -2,15 +2,32 @@
 
 #include "gskvulkansubdescriptorsprivate.h"
 
-struct _GskVulkanSubDescriptors
+
+static void     gsk_vulkan_sub_descriptors_finalize   (GskGpuDescriptors *desc);
+static gboolean gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
+                                                       GskGpuBuffer      *buffer,
+                                                       guint32           *out_descriptor);
+static gboolean gsk_vulkan_sub_descriptors_add_image  (GskGpuDescriptors *desc,
+                                                       GskGpuImage       *image,
+                                                       GskGpuSampler      sampler,
+                                                       guint32           *out_descriptor);
+static GskVulkanPipelineLayout *
+                gsk_vulkan_sub_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc);
+static void     gsk_vulkan_sub_descriptors_bind       (GskVulkanDescriptors *desc,
+                                                       GskVulkanDescriptors *previous,
+                                                       VkCommandBuffer       vk_command_buffer);
+
+static GskVulkanDescriptorsClass GSK_VULKAN_SUB_DESCRIPTORS_CLASS =
 {
-  GskVulkanDescriptors parent_instance;
-
-  GskVulkanDescriptors *parent;
+  .parent_class = (GskGpuDescriptorsClass) {
+    .finalize = gsk_vulkan_sub_descriptors_finalize,
+    .add_image = gsk_vulkan_sub_descriptors_add_image,
+    .add_buffer = gsk_vulkan_sub_descriptors_add_buffer,
+  },
+  .get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout,
+  .bind = gsk_vulkan_sub_descriptors_bind,
 };
 
-G_DEFINE_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS)
-
 static GskVulkanPipelineLayout *
 gsk_vulkan_sub_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc)
 {
@@ -26,7 +43,7 @@ gsk_vulkan_sub_descriptors_bind (GskVulkanDescriptors *desc,
 {
   GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
 
-  if (GSK_IS_VULKAN_SUB_DESCRIPTORS (previous))
+  if (GSK_GPU_DESCRIPTORS (previous)->desc_class == (GskGpuDescriptorsClass *) &GSK_VULKAN_SUB_DESCRIPTORS_CLASS)
     previous = GSK_VULKAN_SUB_DESCRIPTORS (previous)->parent;
 
   if (self->parent == previous)
@@ -62,45 +79,35 @@ gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
 }
 
 static void
-gsk_vulkan_sub_descriptors_finalize (GObject *object)
+gsk_vulkan_sub_descriptors_finalize (GskGpuDescriptors *desc)
 {
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (object);
+  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
 
-  g_object_unref (self->parent);
+  gsk_gpu_descriptors_unref (GSK_GPU_DESCRIPTORS (self->parent));
 
-  G_OBJECT_CLASS (gsk_vulkan_sub_descriptors_parent_class)->finalize (object);
-}
-
-static void
-gsk_vulkan_sub_descriptors_class_init (GskVulkanSubDescriptorsClass *klass)
-{
-  GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass);
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_vulkan_sub_descriptors_finalize;
-
-  descriptors_class->add_image = gsk_vulkan_sub_descriptors_add_image;
-  descriptors_class->add_buffer = gsk_vulkan_sub_descriptors_add_buffer;
-
-  vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout;
-  vulkan_descriptors_class->bind = gsk_vulkan_sub_descriptors_bind;
+  gsk_vulkan_descriptors_finalize (GSK_VULKAN_DESCRIPTORS (self));
 }
 
 static void
 gsk_vulkan_sub_descriptors_init (GskVulkanSubDescriptors *self)
 {
+  gsk_vulkan_descriptors_init (GSK_VULKAN_DESCRIPTORS (self));
 }
 
 GskVulkanSubDescriptors *
 gsk_vulkan_sub_descriptors_new (GskVulkanDescriptors *parent)
 {
   GskVulkanSubDescriptors *self;
+  GskGpuDescriptors *desc;
 
-  self = g_object_new (GSK_TYPE_VULKAN_SUB_DESCRIPTORS, NULL);
+  self = g_new0 (GskVulkanSubDescriptors, 1);
+  desc = GSK_GPU_DESCRIPTORS (self);
 
-  self->parent = g_object_ref (parent);
+  desc->ref_count = 1;
+  desc->desc_class = (GskGpuDescriptorsClass *) &GSK_VULKAN_SUB_DESCRIPTORS_CLASS;
+  gsk_vulkan_sub_descriptors_init (self);
+
+  self->parent = GSK_VULKAN_DESCRIPTORS (gsk_gpu_descriptors_ref (GSK_GPU_DESCRIPTORS (parent)));
 
   return self;
 }
-

gsk/gpu/gskvulkansubdescriptorsprivate.h

@@ -4,9 +4,16 @@
 
 G_BEGIN_DECLS
 
-#define GSK_TYPE_VULKAN_SUB_DESCRIPTORS (gsk_vulkan_sub_descriptors_get_type ())
+typedef struct _GskVulkanSubDescriptors GskVulkanSubDescriptors;
 
-G_DECLARE_FINAL_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK, VULKAN_SUB_DESCRIPTORS, GskVulkanDescriptors)
+#define GSK_VULKAN_SUB_DESCRIPTORS(d) ((GskVulkanSubDescriptors *) (d))
+
+struct _GskVulkanSubDescriptors
+{
+  GskVulkanDescriptors parent_instance;
+
+  GskVulkanDescriptors *parent;
+};
 
 GskVulkanSubDescriptors *       gsk_vulkan_sub_descriptors_new          (GskVulkanDescriptors           *parent);
 

gtk/gtktextlinedisplaycache.c

@@ -50,6 +50,9 @@ struct _GtkTextLineDisplayCache
 #endif
 };
 
+static GQueue purge_in_idle;
+static guint purge_in_idle_source;
+
 #if DEBUG_LINE_DISPLAY_CACHE
 # define STAT_ADD(val,n) ((val) += n)
 # define STAT_INC(val)   STAT_ADD(val,1)
@@ -78,7 +81,7 @@ gtk_text_line_display_cache_new (void)
   GtkTextLineDisplayCache *ret;
 
   ret = g_new0 (GtkTextLineDisplayCache, 1);
-  ret->sorted_by_line = g_sequence_new ((GDestroyNotify)gtk_text_line_display_unref);
+  ret->sorted_by_line = g_sequence_new (NULL);
   ret->line_to_display = g_hash_table_new (NULL, NULL);
   ret->mru_size = DEFAULT_MRU_SIZE;
 
@@ -98,6 +101,8 @@ gtk_text_line_display_cache_free (GtkTextLineDisplayCache *cache)
 
   gtk_text_line_display_cache_invalidate (cache);
 
+  g_assert (g_sequence_get_begin_iter (cache->sorted_by_line) == g_sequence_get_end_iter (cache->sorted_by_line));
+
   g_clear_pointer (&cache->evict_source, g_source_destroy);
   g_clear_pointer (&cache->sorted_by_line, g_sequence_free);
   g_clear_pointer (&cache->line_to_display, g_hash_table_unref);
@@ -211,6 +216,31 @@ gtk_text_line_display_cache_take_display (GtkTextLineDisplayCache *cache,
     }
 }
 
+static gboolean
+purge_text_line_display_in_idle (gpointer data)
+{
+  GQueue q = purge_in_idle;
+
+  purge_in_idle.head = NULL;
+  purge_in_idle.tail = NULL;
+  purge_in_idle.length = 0;
+
+  while (q.head)
+    {
+      GtkTextLineDisplay *display = q.head->data;
+      g_queue_unlink (&q, &display->mru_link);
+      gtk_text_line_display_unref (display);
+    }
+
+  if (purge_in_idle.head == NULL)
+    {
+      purge_in_idle_source = 0;
+      return G_SOURCE_REMOVE;
+    }
+
+  return G_SOURCE_CONTINUE;
+}
+
 /*
  * gtk_text_line_display_cache_invalidate_display:
  * @cache: a GtkTextLineDisplayCache
@@ -250,7 +280,28 @@ gtk_text_line_display_cache_invalidate_display (GtkTextLineDisplayCache *cache,
       g_queue_unlink (&cache->mru, &display->mru_link);
 
       if (iter != NULL)
-        g_sequence_remove (iter);
+        {
+          g_sequence_remove (iter);
+
+          g_queue_push_head_link (&purge_in_idle, &display->mru_link);
+
+          /* Purging a lot of GtkTextLineDisplay while processing a frame
+           * can increase the chances that we miss our frame deadline. Instead
+           * defer that work to right after the frame has completed. This can
+           * help situations where we have large, zoomed out TextView like
+           * those used in an overview map.
+           */
+          if G_UNLIKELY (purge_in_idle_source == 0)
+            {
+              GSource *source;
+
+              purge_in_idle_source = g_idle_add_full (G_PRIORITY_LOW,
+                                                      purge_text_line_display_in_idle,
+                                                      NULL, NULL);
+              source = g_main_context_find_source_by_id (NULL, purge_in_idle_source);
+              g_source_set_static_name (source, "[gtk+ line-display-cache-gc]");
+            }
+        }
     }
 
   STAT_INC (cache->inval);