GNOME.org
 

[mutter/gbsneto/kill-vblank: 61/62] cogl-framebuffer: Remove swap_throttled config

commit 0232d7b6e494bcb3ae9e07e73877615f77ccb9b5
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/micro-perf/Makefile.am          |  24 ----
 cogl/tests/micro-perf/test-journal.c       | 190 -----------------------------
 src/backends/native/meta-renderer-native.c |   2 -
 18 files changed, 60 insertions(+), 411 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 99ac2fba9..ac4742ecb 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 1adbf4128..120b0579e 100644
--- a/cogl/cogl/cogl-onscreen-template.c
+++ b/cogl/cogl/cogl-onscreen-template.c
@@ -64,7 +64,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;
 
@@ -88,14 +87,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 2dd737bef..d8df45820 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 e766e59d0..5b25c1e35 100644
--- a/cogl/cogl/cogl-onscreen.c
+++ b/cogl/cogl/cogl-onscreen.c
@@ -559,20 +559,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 bf36bfb51..b6dcf0a32 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 c1cd50e07..51c759367 100644
--- a/cogl/cogl/cogl.symbols
+++ b/cogl/cogl/cogl.symbols
@@ -584,7 +584,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
@@ -593,7 +592,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
@@ -603,7 +601,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 73648f663..dc7e41a2f 100644
--- a/cogl/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/cogl/winsys/cogl-winsys-egl.c
@@ -729,10 +729,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;
@@ -859,21 +856,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)
 {
@@ -990,8 +972,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 74b0895d1..60e0b7297 100644
--- a/cogl/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/cogl/winsys/cogl-winsys-glx.c
@@ -1687,13 +1687,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);
 
@@ -2076,16 +2070,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
@@ -2252,71 +2238,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);
 
@@ -2334,23 +2315,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)
@@ -3024,8 +2988,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 ba49a9419..7e3687612 100644
--- a/cogl/cogl/winsys/cogl-winsys-stub.c
+++ b/cogl/cogl/winsys/cogl-winsys-stub.c
@@ -145,11 +145,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)
@@ -186,8 +181,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 3be282fc2..fed77d904 100644
--- a/cogl/configure.ac
+++ b/cogl/configure.ac
@@ -969,7 +969,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/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
index d90c419cb..76fcb218a 100644
--- a/src/backends/native/meta-renderer-native.c
+++ b/src/backends/native/meta-renderer-native.c
@@ -2594,8 +2594,6 @@ meta_renderer_native_create_onscreen (MetaRendererNative   *renderer_native,
     }
 
   onscreen = cogl_onscreen_new (context, width, height);
-  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]