diff --git a/src/core/display.c b/src/core/display.c
index 73583828e..81267d161 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -1143,7 +1143,8 @@ void
 meta_display_close (MetaDisplay *display,
                     guint32      timestamp)
 {
-  g_assert (display != NULL);
+  MetaCompositor *compositor;
+  MetaLaters *laters;
 
   if (display->closing != 0)
     {
@@ -1169,10 +1170,12 @@ meta_display_close (MetaDisplay *display,
   g_clear_handle_id (&display->focus_timeout_id, g_source_remove);
   g_clear_handle_id (&display->tile_preview_timeout_id, g_source_remove);
 
+  compositor = meta_display_get_compositor (display);
+  laters = meta_compositor_get_laters (compositor);
   if (display->work_area_later != 0)
-    meta_later_remove (display->work_area_later);
+    meta_laters_remove (laters, display->work_area_later);
   if (display->check_fullscreen_later != 0)
-    meta_later_remove (display->check_fullscreen_later);
+    meta_laters_remove (laters, display->check_fullscreen_later);
 
   /* Stop caring about events */
   meta_display_free_events (display);
@@ -3468,13 +3471,15 @@ meta_display_queue_workarea_recalc (MetaDisplay *display)
   /* Recompute work area later before redrawing */
   if (display->work_area_later == 0)
     {
+      MetaLaters *laters = meta_compositor_get_laters (display->compositor);
+
       meta_topic (META_DEBUG_WORKAREA,
                   "Adding work area hint computation function");
       display->work_area_later =
-        meta_later_add (META_LATER_BEFORE_REDRAW,
-                        (GSourceFunc) set_work_area_later_func,
-                        display,
-                        NULL);
+        meta_laters_add (laters, META_LATER_BEFORE_REDRAW,
+                         (GSourceFunc) set_work_area_later_func,
+                         display,
+                         NULL);
     }
 }
 
@@ -3589,10 +3594,16 @@ check_fullscreen_func (gpointer data)
 void
 meta_display_queue_check_fullscreen (MetaDisplay *display)
 {
-  if (!display->check_fullscreen_later)
-    display->check_fullscreen_later = meta_later_add (META_LATER_CHECK_FULLSCREEN,
-                                                      check_fullscreen_func,
-                                                      display, NULL);
+  MetaLaters *laters;
+
+  if (display->check_fullscreen_later)
+    return;
+
+  laters = meta_compositor_get_laters (display->compositor);
+  display->check_fullscreen_later = meta_laters_add (laters,
+                                                     META_LATER_CHECK_FULLSCREEN,
+                                                     check_fullscreen_func,
+                                                     display, NULL);
 }
 
 int
diff --git a/src/meta/common.h b/src/meta/common.h
index 2c516a70d..edadd74fd 100644
--- a/src/meta/common.h
+++ b/src/meta/common.h
@@ -462,7 +462,7 @@ void meta_frame_borders_clear (MetaFrameBorders *self);
  * coalesce multiple things together, the appropriate place to
  * do it is usually META_PRIORITY_BEFORE_REDRAW.
  *
- * Note that its usually better to use meta_later_add() rather
+ * Note that its usually better to use meta_laters_add() rather
  * than calling g_idle_add() directly; this will make sure things
  * get run when added from a clutter event handler without
  * waiting for another repaint cycle.
diff --git a/src/tests/meta-test-utils.c b/src/tests/meta-test-utils.c
index a52f92b77..ebeb95758 100644
--- a/src/tests/meta-test-utils.c
+++ b/src/tests/meta-test-utils.c
@@ -447,14 +447,18 @@ void
 meta_test_client_wait_for_window_shown (MetaTestClient *client,
                                         MetaWindow     *window)
 {
+  MetaDisplay *display = meta_window_get_display (window);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  MetaLaters *laters = meta_compositor_get_laters (compositor);
+
   WaitForShownData data = {
     .loop = g_main_loop_new (NULL, FALSE),
     .window = window,
   };
-  meta_later_add (META_LATER_BEFORE_REDRAW,
-                  wait_for_showing_before_redraw,
-                  &data,
-                  NULL);
+  meta_laters_add (laters, META_LATER_BEFORE_REDRAW,
+                   wait_for_showing_before_redraw,
+                   &data,
+                   NULL);
   g_main_loop_run (data.loop);
   g_clear_signal_handler (&data.shown_handler_id, window);
   g_main_loop_unref (data.loop);
diff --git a/src/tests/monitor-unit-tests.c b/src/tests/monitor-unit-tests.c
index 91dc52fe4..5c027b968 100644
--- a/src/tests/monitor-unit-tests.c
+++ b/src/tests/monitor-unit-tests.c
@@ -8338,13 +8338,16 @@ quit_main_loop (gpointer data)
 static void
 dispatch (void)
 {
+  MetaDisplay *display = meta_context_get_display (test_context);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  MetaLaters *laters = meta_compositor_get_laters (compositor);
   GMainLoop *loop;
 
   loop = g_main_loop_new (NULL, FALSE);
-  meta_later_add (META_LATER_BEFORE_REDRAW,
-                  quit_main_loop,
-                  loop,
-                  NULL);
+  meta_laters_add (laters, META_LATER_BEFORE_REDRAW,
+                   quit_main_loop,
+                   loop,
+                   NULL);
   g_main_loop_run (loop);
 }
 
diff --git a/src/tests/test-runner.c b/src/tests/test-runner.c
index 15d0a4b20..ec9e94a3c 100644
--- a/src/tests/test-runner.c
+++ b/src/tests/test-runner.c
@@ -113,16 +113,19 @@ test_case_dispatch (TestCase *test,
 {
   MetaBackend *backend = meta_context_get_backend (test->context);
   ClutterActor *stage = meta_backend_get_stage (backend);
+  MetaDisplay *display = meta_context_get_display (test->context);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  MetaLaters *laters = meta_compositor_get_laters (compositor);
 
   /* Wait until we've done any outstanding queued up work.
    * Though we add this as BEFORE_REDRAW, the iteration that runs the
    * BEFORE_REDRAW idles will proceed on and do the redraw, so we're
    * waiting until after *all* frame processing.
    */
-  meta_later_add (META_LATER_BEFORE_REDRAW,
-                  test_case_loop_quit,
-                  test,
-                  NULL);
+  meta_laters_add (laters, META_LATER_BEFORE_REDRAW,
+                   test_case_loop_quit,
+                   test,
+                   NULL);
 
   clutter_stage_schedule_update (CLUTTER_STAGE (stage));
   g_main_loop_run (test->loop);
diff --git a/src/tests/unit-tests.c b/src/tests/unit-tests.c
index 0fefb8d55..75c65b21f 100644
--- a/src/tests/unit-tests.c
+++ b/src/tests/unit-tests.c
@@ -28,7 +28,9 @@
 #include <meta/util.h>
 
 #include "core/boxes-private.h"
+#include "core/display-private.h"
 #include "meta-test/meta-context-test.h"
+#include "meta/compositor.h"
 #include "meta/meta-context.h"
 #include "tests/boxes-tests.h"
 #include "tests/monitor-config-migration-unit-tests.h"
@@ -64,6 +66,9 @@ test_later_order_callback (gpointer user_data)
 static void
 meta_test_util_later_order (void)
 {
+  MetaDisplay *display = meta_context_get_display (test_context);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  MetaLaters *laters = meta_compositor_get_laters (compositor);
   GMainLoop *loop;
   int expected_callback_num;
   int i;
@@ -82,10 +87,10 @@ meta_test_util_later_order (void)
         .callback_num = i,
         .expected_callback_num = &expected_callback_num,
       };
-      meta_later_add (META_LATER_BEFORE_REDRAW,
-                      test_later_order_callback,
-                      &callback_data[i],
-                      NULL);
+      meta_laters_add (laters, META_LATER_BEFORE_REDRAW,
+                       test_later_order_callback,
+                       &callback_data[i],
+                       NULL);
     }
 
   /* Check that the callbacks are invoked in the opposite order that they were
@@ -119,13 +124,16 @@ static gboolean
 test_later_schedule_from_later_calc_showing_callback (gpointer user_data)
 {
   MetaTestLaterScheduleFromLaterData *data = user_data;
+  MetaDisplay *display = meta_context_get_display (test_context);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  MetaLaters *laters = meta_compositor_get_laters (compositor);
 
   g_assert_cmpint (data->state, ==, META_TEST_LATER_EXPECT_CALC_SHOWING);
 
-  meta_later_add (META_LATER_SYNC_STACK,
-                  test_later_schedule_from_later_sync_stack_callback,
-                  data,
-                  NULL);
+  meta_laters_add (laters, META_LATER_SYNC_STACK,
+                   test_later_schedule_from_later_sync_stack_callback,
+                   data,
+                   NULL);
 
   data->state = META_TEST_LATER_EXPECT_SYNC_STACK;
 
@@ -160,6 +168,9 @@ static void
 meta_test_util_later_schedule_from_later (void)
 {
   MetaTestLaterScheduleFromLaterData data;
+  MetaDisplay *display = meta_context_get_display (test_context);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  MetaLaters *laters = meta_compositor_get_laters (compositor);
 
   data.loop = g_main_loop_new (NULL, FALSE);
 
@@ -170,14 +181,14 @@ meta_test_util_later_schedule_from_later (void)
    * The first and last callback is queued here. The one to be invoked in
    * between is invoked in test_later_schedule_from_later_calc_showing_callback.
    */
-  meta_later_add (META_LATER_CALC_SHOWING,
-                  test_later_schedule_from_later_calc_showing_callback,
-                  &data,
-                  NULL);
-  meta_later_add (META_LATER_BEFORE_REDRAW,
-                  test_later_schedule_from_later_before_redraw_callback,
-                  &data,
-                  NULL);
+  meta_laters_add (laters, META_LATER_CALC_SHOWING,
+                   test_later_schedule_from_later_calc_showing_callback,
+                   &data,
+                   NULL);
+  meta_laters_add (laters, META_LATER_BEFORE_REDRAW,
+                   test_later_schedule_from_later_before_redraw_callback,
+                   &data,
+                   NULL);
 
   data.state = META_TEST_LATER_EXPECT_CALC_SHOWING;