[mutter/gbsneto/kill-vblank: 90/91] cogl-framebuffer: Remove swap_throttled config



commit 932c88d9d1bddc33ec985bd5f776587a2a4f595d
Author: Georges Basile Stavracas Neto <georges stavracas gmail com>
Date:   Wed Aug 8 17:09:55 2018 -0300

    cogl-framebuffer: Remove swap_throttled config
    
    Since now we don't set the swap throttled value based
    on sync-to-vblank, we can effectively remove it from
    Cogl. Throttling swap buffers in Cogl is as much a
    historical artifact as sync-to-vblank. Furthermore,
    it doesn't make sense to disable it on a compositor,
    which is the case with the embedded Cogl.
    
    In addition to that, the winsys vfunc for updating
    whenever swap throttling changes could also be removed,
    since swap throttling is always enabled now.
    
    Removing it means less code, less branches when running,
    and one less config option to deal with.
    
    This also removes the micro-perf test, since it doesn't
    make sense for the case where Cogl is embedded into the
    compositor.
    
    https://gitlab.gnome.org/GNOME/mutter/merge_requests/191

 clutter/clutter/x11/clutter-stage-x11.c    |   1 -
 cogl/.gitignore                            |   1 -
 cogl/cogl/cogl-framebuffer-private.h       |   1 -
 cogl/cogl/cogl-onscreen-private.h          |   2 -
 cogl/cogl/cogl-onscreen-template.c         |   9 --
 cogl/cogl/cogl-onscreen-template.h         |  17 ---
 cogl/cogl/cogl-onscreen.c                  |  14 ---
 cogl/cogl/cogl-onscreen.h                  |  22 +---
 cogl/cogl/cogl.symbols                     |   3 -
 cogl/cogl/winsys/cogl-winsys-egl.c         |  22 +---
 cogl/cogl/winsys/cogl-winsys-glx.c         | 148 +++++++++-------------
 cogl/cogl/winsys/cogl-winsys-private.h     |   3 -
 cogl/cogl/winsys/cogl-winsys-stub.c        |   7 --
 cogl/configure.ac                          |   1 -
 cogl/tests/Makefile.am                     |   4 +-
 cogl/tests/meson.build                     |   1 -
 cogl/tests/micro-perf/Makefile.am          |  24 ----
 cogl/tests/micro-perf/meson.build          |  18 ---
 cogl/tests/micro-perf/test-journal.c       | 190 -----------------------------
 src/backends/native/meta-renderer-native.c |   3 -
 20 files changed, 60 insertions(+), 431 deletions(-)
---
diff --git a/clutter/clutter/x11/clutter-stage-x11.c b/clutter/clutter/x11/clutter-stage-x11.c
index ee7857cb6..62a67708e 100644
--- a/clutter/clutter/x11/clutter-stage-x11.c
+++ b/clutter/clutter/x11/clutter-stage-x11.c
@@ -631,7 +631,6 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window)
 
   stage_x11->onscreen = cogl_onscreen_new (backend->cogl_context, width, height);
 
-  cogl_onscreen_set_swap_throttled (stage_x11->onscreen, TRUE);
   stage_x11->frame_closure =
     cogl_onscreen_add_frame_callback (stage_x11->onscreen,
                                       frame_cb,
diff --git a/cogl/.gitignore b/cogl/.gitignore
index 8449b17fd..7f7367087 100644
--- a/cogl/.gitignore
+++ b/cogl/.gitignore
@@ -66,7 +66,6 @@ TAGS
 /tests/conform/config.env
 /tests/conform/.log
 /tests/unit/.log
-/tests/micro-perf/test-journal
 /tests/config.env
 /po/POTFILES
 /po/*.gmo
diff --git a/cogl/cogl/cogl-framebuffer-private.h b/cogl/cogl/cogl-framebuffer-private.h
index 3701eab21..d78bd408d 100644
--- a/cogl/cogl/cogl-framebuffer-private.h
+++ b/cogl/cogl/cogl-framebuffer-private.h
@@ -59,7 +59,6 @@ typedef struct
   CoglSwapChain *swap_chain;
   CoglBool need_stencil;
   int samples_per_pixel;
-  CoglBool swap_throttled;
   CoglBool depth_texture_enabled;
   CoglBool stereo_enabled;
 } CoglFramebufferConfig;
diff --git a/cogl/cogl/cogl-onscreen-private.h b/cogl/cogl/cogl-onscreen-private.h
index 0a67832ac..5a4aebc2e 100644
--- a/cogl/cogl/cogl-onscreen-private.h
+++ b/cogl/cogl/cogl-onscreen-private.h
@@ -65,8 +65,6 @@ struct _CoglOnscreen
   void *foreign_update_mask_data;
 #endif
 
-  CoglBool swap_throttled;
-
   CoglList frame_closures;
 
   CoglBool resizable;
diff --git a/cogl/cogl/cogl-onscreen-template.c b/cogl/cogl/cogl-onscreen-template.c
index 0e7bd1e20..6fcbe5d7c 100644
--- a/cogl/cogl/cogl-onscreen-template.c
+++ b/cogl/cogl/cogl-onscreen-template.c
@@ -62,7 +62,6 @@ cogl_onscreen_template_new (CoglSwapChain *swap_chain)
   else
     onscreen_template->config.swap_chain = cogl_swap_chain_new ();
 
-  onscreen_template->config.swap_throttled = TRUE;
   onscreen_template->config.need_stencil = TRUE;
   onscreen_template->config.samples_per_pixel = 0;
 
@@ -86,14 +85,6 @@ cogl_onscreen_template_set_samples_per_pixel (
   onscreen_template->config.samples_per_pixel = samples_per_pixel;
 }
 
-void
-cogl_onscreen_template_set_swap_throttled (
-                                          CoglOnscreenTemplate *onscreen_template,
-                                          CoglBool throttled)
-{
-  onscreen_template->config.swap_throttled = throttled;
-}
-
 void
 cogl_onscreen_template_set_stereo_enabled (
                                           CoglOnscreenTemplate *onscreen_template,
diff --git a/cogl/cogl/cogl-onscreen-template.h b/cogl/cogl/cogl-onscreen-template.h
index 9831375e6..52dcdcfaa 100644
--- a/cogl/cogl/cogl-onscreen-template.h
+++ b/cogl/cogl/cogl-onscreen-template.h
@@ -85,23 +85,6 @@ cogl_onscreen_template_set_samples_per_pixel (
                                           CoglOnscreenTemplate *onscreen_template,
                                           int n);
 
-/**
- * cogl_onscreen_template_set_swap_throttled:
- * @onscreen_template: A #CoglOnscreenTemplate template framebuffer
- * @throttled: Whether throttling should be enabled
- *
- * Requests that any future #CoglOnscreen framebuffers derived from this
- * template should enable or disable swap throttling according to the given
- * @throttled argument.
- *
- * Since: 1.10
- * Stability: unstable
- */
-void
-cogl_onscreen_template_set_swap_throttled (
-                                          CoglOnscreenTemplate *onscreen_template,
-                                          CoglBool throttled);
-
 /**
  * cogl_onscreen_template_set_stereo_enabled:
  * @onscreen_template: A #CoglOnscreenTemplate template framebuffer
diff --git a/cogl/cogl/cogl-onscreen.c b/cogl/cogl/cogl-onscreen.c
index 4e01d133d..f5db270c8 100644
--- a/cogl/cogl/cogl-onscreen.c
+++ b/cogl/cogl/cogl-onscreen.c
@@ -557,20 +557,6 @@ cogl_onscreen_remove_swap_buffers_callback (CoglOnscreen *onscreen,
   cogl_onscreen_remove_frame_callback (onscreen, closure);
 }
 
-void
-cogl_onscreen_set_swap_throttled (CoglOnscreen *onscreen,
-                                  CoglBool throttled)
-{
-  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
-  framebuffer->config.swap_throttled = throttled;
-  if (framebuffer->allocated)
-    {
-      const CoglWinsysVtable *winsys =
-        _cogl_framebuffer_get_winsys (framebuffer);
-      winsys->onscreen_update_swap_throttled (onscreen);
-    }
-}
-
 void
 cogl_onscreen_show (CoglOnscreen *onscreen)
 {
diff --git a/cogl/cogl/cogl-onscreen.h b/cogl/cogl/cogl-onscreen.h
index a4f062ecb..675a32a4b 100644
--- a/cogl/cogl/cogl-onscreen.h
+++ b/cogl/cogl/cogl-onscreen.h
@@ -162,23 +162,6 @@ uint32_t
 cogl_x11_onscreen_get_visual_xid (CoglOnscreen *onscreen);
 #endif /* COGL_HAS_X11 */
 
-/**
- * cogl_onscreen_set_swap_throttled:
- * @onscreen: A #CoglOnscreen framebuffer
- * @throttled: Whether swap throttling is wanted or not.
- *
- * Requests that the given @onscreen framebuffer should have swap buffer
- * requests (made using cogl_onscreen_swap_buffers()) throttled either by a
- * displays vblank period or perhaps some other mechanism in a composited
- * environment.
- *
- * Since: 1.8
- * Stability: unstable
- */
-void
-cogl_onscreen_set_swap_throttled (CoglOnscreen *onscreen,
-                                  CoglBool throttled);
-
 /**
  * cogl_onscreen_show:
  * @onscreen: The onscreen framebuffer to make visible
@@ -554,9 +537,8 @@ typedef void (*CoglSwapBuffersNotify) (CoglFramebuffer *framebuffer,
  * registered callbacks will be called if this feature is not supported.</note>
  *
  * We recommend using this mechanism when available to manually throttle your
- * applications (in conjunction with  cogl_onscreen_set_swap_throttled()) so
- * your application will be able to avoid long blocks in the driver caused by
- * throttling when you request to swap buffers too quickly.
+ * applications so your application will be able to avoid long blocks in the
+ * driver caused by throttling when you request to swap buffers too quickly.
  *
  * Return value: a unique identifier that can be used to remove to remove
  *               the callback later.
diff --git a/cogl/cogl/cogl.symbols b/cogl/cogl/cogl.symbols
index d7f700012..68a624f4a 100644
--- a/cogl/cogl/cogl.symbols
+++ b/cogl/cogl/cogl.symbols
@@ -578,7 +578,6 @@ cogl_onscreen_get_gtype
 cogl_onscreen_get_resizable
 cogl_onscreen_hide
 cogl_onscreen_new
-cogl_onscreen_set_swap_throttled
 cogl_onscreen_remove_dirty_callback
 cogl_onscreen_remove_frame_callback
 cogl_onscreen_remove_resize_callback
@@ -587,7 +586,6 @@ cogl_onscreen_remove_swap_buffers_callback
 cogl_onscreen_resize_closure_get_gtype
 #endif
 cogl_onscreen_set_resizable
-cogl_onscreen_set_swap_throttled
 cogl_onscreen_show
 cogl_onscreen_swap_buffers
 cogl_onscreen_swap_buffers_with_damage
@@ -597,7 +595,6 @@ cogl_onscreen_template_get_gtype
 #endif
 cogl_onscreen_template_new
 cogl_onscreen_template_set_samples_per_pixel
-cogl_onscreen_template_set_swap_throttled
 
 cogl_ortho
 
diff --git a/cogl/cogl/winsys/cogl-winsys-egl.c b/cogl/cogl/winsys/cogl-winsys-egl.c
index 6e43d2227..fc6025dee 100644
--- a/cogl/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/cogl/winsys/cogl-winsys-egl.c
@@ -724,10 +724,7 @@ bind_onscreen_with_context (CoglOnscreen *onscreen,
       CoglRenderer *renderer = context->display->renderer;
       CoglRendererEGL *egl_renderer = renderer->winsys;
 
-      if (fb->config.swap_throttled)
-        eglSwapInterval (egl_renderer->edpy, 1);
-      else
-        eglSwapInterval (egl_renderer->edpy, 0);
+      eglSwapInterval (egl_renderer->edpy, 1);
     }
 
   return status;
@@ -854,21 +851,6 @@ _cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
     eglSwapBuffers (egl_renderer->edpy, egl_onscreen->egl_surface);
 }
 
-static void
-_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen)
-{
-  CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
-  CoglDisplayEGL *egl_display = context->display->winsys;
-  CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
-
-  if (egl_display->current_draw_surface != egl_onscreen->egl_surface)
-    return;
-
-  egl_display->current_draw_surface = EGL_NO_SURFACE;
-
-  _cogl_winsys_onscreen_bind (onscreen);
-}
-
 static void
 _cogl_winsys_save_context (CoglContext *ctx)
 {
@@ -985,8 +967,6 @@ static CoglWinsysVtable _cogl_winsys_vtable =
       _cogl_winsys_onscreen_swap_buffers_with_damage,
     .onscreen_swap_region = _cogl_winsys_onscreen_swap_region,
     .onscreen_get_buffer_age = _cogl_winsys_onscreen_get_buffer_age,
-    .onscreen_update_swap_throttled =
-      _cogl_winsys_onscreen_update_swap_throttled,
 
     /* CoglGLES2Context related methods */
     .save_context = _cogl_winsys_save_context,
diff --git a/cogl/cogl/winsys/cogl-winsys-glx.c b/cogl/cogl/winsys/cogl-winsys-glx.c
index 2226ee942..b691b34d2 100644
--- a/cogl/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/cogl/winsys/cogl-winsys-glx.c
@@ -1685,13 +1685,7 @@ _cogl_winsys_onscreen_bind (CoglOnscreen *onscreen)
    * exclusive.
    */
   if (glx_renderer->glXSwapInterval)
-    {
-      CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
-      if (fb->config.swap_throttled)
-        glx_renderer->glXSwapInterval (1);
-      else
-        glx_renderer->glXSwapInterval (0);
-    }
+    glx_renderer->glXSwapInterval (1);
 
   XSync (xlib_renderer->xdpy, False);
 
@@ -2074,16 +2068,8 @@ _cogl_winsys_onscreen_swap_region (CoglOnscreen *onscreen,
                                  framebuffer,
                                  COGL_FRAMEBUFFER_STATE_BIND);
 
-  if (framebuffer->config.swap_throttled)
-    {
-      have_counter = glx_display->have_vblank_counter;
-      can_wait = glx_display->can_vblank_wait;
-    }
-  else
-    {
-      have_counter = FALSE;
-      can_wait = FALSE;
-    }
+  have_counter = glx_display->have_vblank_counter;
+  can_wait = glx_display->can_vblank_wait;
 
   /* We need to ensure that all the rendering is done, otherwise
    * redraw operations that are slower than the framerate can
@@ -2250,71 +2236,66 @@ _cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
 
   drawable = glx_onscreen->glxwin ? glx_onscreen->glxwin : xlib_onscreen->xwin;
 
-  if (framebuffer->config.swap_throttled)
-    {
-      have_counter = glx_display->have_vblank_counter;
+  have_counter = glx_display->have_vblank_counter;
 
-      if (glx_renderer->glXSwapInterval)
-        {
-          if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_THREADED_SWAP_WAIT))
-            {
-             /* If we didn't wait for the GPU here, then it's easy to get the case
-              * where there is a VBlank between the point where we get the vsync counter
-              * and the point where the GPU is ready to actually perform the glXSwapBuffers(),
-              * and the swap wait terminates at the first VBlank rather than the one
-              * where the swap buffers happens. Calling glFinish() here makes this a
-              * rare race since the GPU is already ready to swap when we call glXSwapBuffers().
-              * The glFinish() also prevents any serious damage if the rare race happens,
-              * since it will wait for the preceding glXSwapBuffers() and prevent us from
-              * getting premanently ahead. (For NVIDIA drivers, glFinish() after glXSwapBuffers()
-              * waits for the buffer swap to happen.)
-              */
-              _cogl_winsys_wait_for_gpu (onscreen);
-              start_threaded_swap_wait (onscreen, _cogl_winsys_get_vsync_counter (context));
-            }
-        }
-      else
+  if (glx_renderer->glXSwapInterval)
+    {
+      if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_THREADED_SWAP_WAIT))
         {
-          CoglBool can_wait = have_counter || glx_display->can_vblank_wait;
-
-          uint32_t end_frame_vsync_counter = 0;
-
-          /* If the swap_region API is also being used then we need to track
-           * the vsync counter for each swap request so we can manually
-           * throttle swap_region requests. */
-          if (have_counter)
-            end_frame_vsync_counter = _cogl_winsys_get_vsync_counter (context);
-
-          /* If we are going to wait for VBLANK manually, we not only
-           * need to flush out pending drawing to the GPU before we
-           * sleep, we need to wait for it to finish. Otherwise, we
-           * may end up with the situation:
-           *
-           *        - We finish drawing      - GPU drawing continues
-           *        - We go to sleep         - GPU drawing continues
-           * VBLANK - We call glXSwapBuffers - GPU drawing continues
-           *                                 - GPU drawing continues
-           *                                 - Swap buffers happens
-           *
-           * Producing a tear. Calling glFinish() first will cause us
-           * to properly wait for the next VBLANK before we swap. This
-           * obviously does not happen when we use _GLX_SWAP and let
-           * the driver do the right thing
+          /* If we didn't wait for the GPU here, then it's easy to get the case
+           * where there is a VBlank between the point where we get the vsync counter
+           * and the point where the GPU is ready to actually perform the glXSwapBuffers(),
+           * and the swap wait terminates at the first VBlank rather than the one
+           * where the swap buffers happens. Calling glFinish() here makes this a
+           * rare race since the GPU is already ready to swap when we call glXSwapBuffers().
+           * The glFinish() also prevents any serious damage if the rare race happens,
+           * since it will wait for the preceding glXSwapBuffers() and prevent us from
+           * getting premanently ahead. (For NVIDIA drivers, glFinish() after glXSwapBuffers()
+           * waits for the buffer swap to happen.)
            */
           _cogl_winsys_wait_for_gpu (onscreen);
+          start_threaded_swap_wait (onscreen, _cogl_winsys_get_vsync_counter (context));
+        }
+    }
+  else
+    {
+      CoglBool can_wait = have_counter || glx_display->can_vblank_wait;
 
-          if (have_counter && can_wait)
-            {
-              if (glx_onscreen->last_swap_vsync_counter ==
-                  end_frame_vsync_counter)
-                _cogl_winsys_wait_for_vblank (onscreen);
-            }
-          else if (can_wait)
+      uint32_t end_frame_vsync_counter = 0;
+
+      /* If the swap_region API is also being used then we need to track
+       * the vsync counter for each swap request so we can manually
+       * throttle swap_region requests. */
+      if (have_counter)
+        end_frame_vsync_counter = _cogl_winsys_get_vsync_counter (context);
+
+      /* If we are going to wait for VBLANK manually, we not only
+       * need to flush out pending drawing to the GPU before we
+       * sleep, we need to wait for it to finish. Otherwise, we
+       * may end up with the situation:
+       *
+       *        - We finish drawing      - GPU drawing continues
+       *        - We go to sleep         - GPU drawing continues
+       * VBLANK - We call glXSwapBuffers - GPU drawing continues
+       *                                 - GPU drawing continues
+       *                                 - Swap buffers happens
+       *
+       * Producing a tear. Calling glFinish() first will cause us
+       * to properly wait for the next VBLANK before we swap. This
+       * obviously does not happen when we use _GLX_SWAP and let
+       * the driver do the right thing
+       */
+      _cogl_winsys_wait_for_gpu (onscreen);
+
+      if (have_counter && can_wait)
+        {
+          if (glx_onscreen->last_swap_vsync_counter ==
+              end_frame_vsync_counter)
             _cogl_winsys_wait_for_vblank (onscreen);
         }
+      else if (can_wait)
+        _cogl_winsys_wait_for_vblank (onscreen);
     }
-  else
-    have_counter = FALSE;
 
   glx_renderer->glXSwapBuffers (xlib_renderer->xdpy, drawable);
 
@@ -2332,23 +2313,6 @@ _cogl_winsys_onscreen_x11_get_window_xid (CoglOnscreen *onscreen)
   return xlib_onscreen->xwin;
 }
 
-static void
-_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen)
-{
-  CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
-  CoglContextGLX *glx_context = context->winsys;
-  CoglOnscreenGLX *glx_onscreen = onscreen->winsys;
-  CoglOnscreenXlib *xlib_onscreen = onscreen->winsys;
-  GLXDrawable drawable =
-    glx_onscreen->glxwin ? glx_onscreen->glxwin : xlib_onscreen->xwin;
-
-  if (glx_context->current_drawable != drawable)
-    return;
-
-  glx_context->current_drawable = 0;
-  _cogl_winsys_onscreen_bind (onscreen);
-}
-
 static void
 _cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen,
                                       CoglBool visibility)
@@ -3022,8 +2986,6 @@ static CoglWinsysVtable _cogl_winsys_vtable =
       _cogl_winsys_onscreen_swap_buffers_with_damage,
     .onscreen_swap_region = _cogl_winsys_onscreen_swap_region,
     .onscreen_get_buffer_age = _cogl_winsys_onscreen_get_buffer_age,
-    .onscreen_update_swap_throttled =
-      _cogl_winsys_onscreen_update_swap_throttled,
     .onscreen_x11_get_window_xid =
       _cogl_winsys_onscreen_x11_get_window_xid,
     .onscreen_set_visibility = _cogl_winsys_onscreen_set_visibility,
diff --git a/cogl/cogl/winsys/cogl-winsys-private.h b/cogl/cogl/winsys/cogl-winsys-private.h
index a8e07a509..101b7b624 100644
--- a/cogl/cogl/winsys/cogl-winsys-private.h
+++ b/cogl/cogl/winsys/cogl-winsys-private.h
@@ -122,9 +122,6 @@ typedef struct _CoglWinsysVtable
                                         const int *rectangles,
                                         int n_rectangles);
 
-  void
-  (*onscreen_update_swap_throttled) (CoglOnscreen *onscreen);
-
   void
   (*onscreen_set_visibility) (CoglOnscreen *onscreen,
                               CoglBool visibility);
diff --git a/cogl/cogl/winsys/cogl-winsys-stub.c b/cogl/cogl/winsys/cogl-winsys-stub.c
index 29c4cf8c9..5bdf7f347 100644
--- a/cogl/cogl/winsys/cogl-winsys-stub.c
+++ b/cogl/cogl/winsys/cogl-winsys-stub.c
@@ -143,11 +143,6 @@ _cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
 {
 }
 
-static void
-_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen)
-{
-}
-
 static void
 _cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen,
                                       CoglBool visibility)
@@ -184,8 +179,6 @@ _cogl_winsys_stub_get_vtable (void)
       vtable.onscreen_bind = _cogl_winsys_onscreen_bind;
       vtable.onscreen_swap_buffers_with_damage =
         _cogl_winsys_onscreen_swap_buffers_with_damage;
-      vtable.onscreen_update_swap_throttled =
-        _cogl_winsys_onscreen_update_swap_throttled;
       vtable.onscreen_set_visibility = _cogl_winsys_onscreen_set_visibility;
 
       vtable_inited = TRUE;
diff --git a/cogl/configure.ac b/cogl/configure.ac
index 4c3f2eb2c..8c02b392c 100644
--- a/cogl/configure.ac
+++ b/cogl/configure.ac
@@ -693,7 +693,6 @@ tests/Makefile
 tests/config.env
 tests/conform/Makefile
 tests/unit/Makefile
-tests/micro-perf/Makefile
 tests/data/Makefile
 )
 
diff --git a/cogl/tests/Makefile.am b/cogl/tests/Makefile.am
index 7e483291f..3d0c1b25d 100644
--- a/cogl/tests/Makefile.am
+++ b/cogl/tests/Makefile.am
@@ -4,9 +4,9 @@ if UNIT_TESTS
 SUBDIRS += unit
 endif
 
-SUBDIRS += micro-perf data
+SUBDIRS += data
 
-DIST_SUBDIRS = conform unit micro-perf data
+DIST_SUBDIRS = conform unit data
 
 EXTRA_DIST = README test-launcher.sh run-tests.sh
 
diff --git a/cogl/tests/meson.build b/cogl/tests/meson.build
index a1853774a..e5b85bbfc 100644
--- a/cogl/tests/meson.build
+++ b/cogl/tests/meson.build
@@ -11,4 +11,3 @@ cogl_config_env = configure_file(
 
 subdir('conform')
 subdir('unit')
-subdir('micro-perf')
diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
index 5ba18a8ae..d7e33fe18 100644
--- a/src/backends/native/meta-renderer-native.c
+++ b/src/backends/native/meta-renderer-native.c
@@ -2727,9 +2727,6 @@ meta_renderer_native_create_onscreen (MetaRendererNative   *renderer_native,
 
   onscreen = cogl_onscreen_new (context, width, height);
 
-  /* We have wait_for_pending_flips hardcoded, so throttling always. */
-  cogl_onscreen_set_swap_throttled (onscreen, TRUE);
-
   if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error))
     {
       cogl_object_unref (onscreen);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]