diff --git a/cogl-pango/cogl-pango-display-list.c b/cogl-pango/cogl-pango-display-list.c
index e31b7a1f1..d23fdbd44 100644
--- a/cogl-pango/cogl-pango-display-list.c
+++ b/cogl-pango/cogl-pango-display-list.c
@@ -352,7 +352,7 @@ emit_vertex_buffer_geometry (CoglFramebuffer *fb,
                                                  2 /* n_attributes */);
 
 #ifdef CLUTTER_COGL_HAS_GL
-      if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_QUADS))
+      if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUADS))
         cogl_primitive_set_mode (prim, GL_QUADS);
       else
 #endif
diff --git a/cogl/cogl-bitmap-conversion.c b/cogl/cogl-bitmap-conversion.c
index ff7c55fb7..e8a86c572 100644
--- a/cogl/cogl-bitmap-conversion.c
+++ b/cogl/cogl-bitmap-conversion.c
@@ -531,8 +531,8 @@ _cogl_bitmap_convert_for_upload (CoglBitmap *src_bmp,
    * won't work correctly to convert to/from component-alpha
    * textures */
 
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FORMAT_CONVERSION) &&
-      ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) ||
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_FORMAT_CONVERSION) &&
+      (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) ||
        (src_format != COGL_PIXEL_FORMAT_A_8 &&
         internal_format != COGL_PIXEL_FORMAT_A_8) ||
        src_format == internal_format))
diff --git a/cogl/cogl-blend-string.c b/cogl/cogl-blend-string.c
index 0d90b66a8..23a40fc58 100644
--- a/cogl/cogl-blend-string.c
+++ b/cogl/cogl-blend-string.c
@@ -245,8 +245,8 @@ validate_blend_statements (CoglBlendStringStatement *statements,
             goto error;
           }
 
-        if (!(ctx->private_feature_flags &
-              COGL_PRIVATE_FEATURE_BLEND_CONSTANT) &&
+        if (!_cogl_has_private_feature (ctx,
+                                        COGL_PRIVATE_FEATURE_BLEND_CONSTANT) &&
             arg->factor.is_color &&
             (arg->factor.source.info->type ==
              COGL_BLEND_STRING_COLOR_SOURCE_CONSTANT))
diff --git a/cogl/cogl-blit.c b/cogl/cogl-blit.c
index fffd9ede6..466d7403d 100644
--- a/cogl/cogl-blit.c
+++ b/cogl/cogl-blit.c
@@ -153,7 +153,7 @@ _cogl_blit_framebuffer_begin (CoglBlitData *data)
      format and the blit framebuffer extension is supported */
   if ((cogl_texture_get_format (data->src_tex) & ~COGL_A_BIT) !=
       (cogl_texture_get_format (data->dst_tex) & ~COGL_A_BIT) ||
-      !(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT))
+      !_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT))
     return FALSE;
 
   dst_offscreen = _cogl_offscreen_new_with_texture_full
diff --git a/cogl/cogl-buffer.c b/cogl/cogl-buffer.c
index 0600e01b9..f31120b9f 100644
--- a/cogl/cogl-buffer.c
+++ b/cogl/cogl-buffer.c
@@ -129,13 +129,13 @@ _cogl_buffer_initialize (CoglBuffer *buffer,
   if (default_target == COGL_BUFFER_BIND_TARGET_PIXEL_PACK ||
       default_target == COGL_BUFFER_BIND_TARGET_PIXEL_UNPACK)
     {
-      if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_PBOS))
+      if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_PBOS))
         use_malloc = TRUE;
     }
   else if (default_target == COGL_BUFFER_BIND_TARGET_ATTRIBUTE_BUFFER ||
            default_target == COGL_BUFFER_BIND_TARGET_INDEX_BUFFER)
     {
-      if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_VBOS))
+      if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_VBOS))
         use_malloc = TRUE;
     }
 
diff --git a/cogl/cogl-context-private.h b/cogl/cogl-context-private.h
index 91a264a6b..7f1b054c3 100644
--- a/cogl/cogl-context-private.h
+++ b/cogl/cogl-context-private.h
@@ -54,6 +54,7 @@
 #include "cogl-fence-private.h"
 #include "cogl-poll-private.h"
 #include "cogl-path/cogl-path-types.h"
+#include "cogl-private.h"
 
 typedef struct
 {
@@ -92,7 +93,8 @@ struct _CoglContext
   /* Features cache */
   unsigned long features[COGL_FLAGS_N_LONGS_FOR_SIZE (_COGL_N_FEATURE_IDS)];
   CoglFeatureFlags feature_flags; /* legacy/deprecated feature flags */
-  CoglPrivateFeatureFlags private_feature_flags;
+  unsigned long private_features
+    [COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_N_PRIVATE_FEATURES)];
 
   CoglBool needs_viewport_scissor_workaround;
   CoglFramebuffer *viewport_scissor_workaround_framebuffer;
diff --git a/cogl/cogl-context.c b/cogl/cogl-context.c
index fb3e2569d..a240954fa 100644
--- a/cogl/cogl-context.c
+++ b/cogl/cogl-context.c
@@ -79,10 +79,10 @@ static void
 _cogl_init_feature_overrides (CoglContext *ctx)
 {
   if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_VBOS)))
-    ctx->private_feature_flags &= ~COGL_PRIVATE_FEATURE_VBOS;
+    COGL_FLAGS_SET (ctx->private_features, COGL_PRIVATE_FEATURE_VBOS, FALSE);
 
   if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_PBOS)))
-    ctx->private_feature_flags &= ~COGL_PRIVATE_FEATURE_PBOS;
+    COGL_FLAGS_SET (ctx->private_features, COGL_PRIVATE_FEATURE_PBOS, FALSE);
 
   if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_ARBFP)))
     {
@@ -179,7 +179,7 @@ cogl_context_new (CoglDisplay *display,
   /* Init default values */
   memset (context->features, 0, sizeof (context->features));
   context->feature_flags = 0;
-  context->private_feature_flags = 0;
+  memset (context->private_features, 0, sizeof (context->private_features));
 
   context->rectangle_state = COGL_WINSYS_RECTANGLE_STATE_UNKNOWN;
 
@@ -219,7 +219,8 @@ cogl_context_new (CoglDisplay *display,
   context->driver_vtable = display->renderer->driver_vtable;
   context->texture_driver = display->renderer->texture_driver;
 
-  context->private_feature_flags |= display->renderer->private_feature_flags;
+  for (i = 0; i < G_N_ELEMENTS (context->private_features); i++)
+    context->private_features[i] |= display->renderer->private_features[i];
 
   winsys = _cogl_context_get_winsys (context);
   if (!winsys->context_init (context, error))
@@ -284,7 +285,7 @@ cogl_context_new (CoglDisplay *display,
   context->texture_units =
     g_array_new (FALSE, FALSE, sizeof (CoglTextureUnit));
 
-  if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_ANY_GL))
+  if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_ANY_GL))
     {
       /* See cogl-pipeline.c for more details about why we leave texture unit 1
        * active by default... */
@@ -396,7 +397,7 @@ cogl_context_new (CoglDisplay *display,
   context->blit_texture_pipeline = NULL;
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
-  if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEST))
+  if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_ALPHA_TEST))
     /* The default for GL_ALPHA_TEST is to always pass which is equivalent to
      * the test being disabled therefore we assume that for all drivers there
      * will be no performance impact if we always leave the test enabled which
@@ -479,7 +480,7 @@ cogl_context_new (CoglDisplay *display,
      pipeline to track whether any layers have point sprite coords
      enabled. We don't need to do this for GL3 or GLES2 because point
      sprites are handled using a builtin varying in the shader. */
-  if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) &&
+  if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_GL_FIXED) &&
       cogl_has_feature (context, COGL_FEATURE_ID_POINT_SPRITE))
     GE (context, glEnable (GL_POINT_SPRITE));
 
diff --git a/cogl/cogl-framebuffer.c b/cogl/cogl-framebuffer.c
index 4957b38fd..7e3305b2d 100644
--- a/cogl/cogl-framebuffer.c
+++ b/cogl/cogl-framebuffer.c
@@ -724,7 +724,7 @@ cogl_framebuffer_allocate (CoglFramebuffer *framebuffer,
        * one on allocation so that if the application only paints in
        * response to dirty events then it will at least paint once to
        * start */
-      if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_DIRTY_EVENTS))
+      if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_DIRTY_EVENTS))
         _cogl_onscreen_queue_full_dirty (onscreen);
     }
   else
@@ -1614,8 +1614,8 @@ _cogl_blit_framebuffer (CoglFramebuffer *src,
 {
   CoglContext *ctx = src->context;
 
-  _COGL_RETURN_IF_FAIL (ctx->private_feature_flags &
-                        COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT);
+  _COGL_RETURN_IF_FAIL (_cogl_has_private_feature
+                        (ctx, COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT));
 
   /* We can only support blitting between offscreen buffers because
      otherwise we would need to mirror the image and GLES2.0 doesn't
diff --git a/cogl/cogl-glsl-shader.c b/cogl/cogl-glsl-shader.c
index 66474bf1a..cfce0f96a 100644
--- a/cogl/cogl-glsl-shader.c
+++ b/cogl/cogl-glsl-shader.c
@@ -96,7 +96,7 @@ _cogl_glsl_shader_set_source_with_boilerplate (CoglContext *ctx,
   strings[count] = version_string;
   lengths[count++] = -1;
 
-  if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED &&
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_EMBEDDED) &&
       cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
     {
       static const char texture_3d_extension[] =
diff --git a/cogl/cogl-journal.c b/cogl/cogl-journal.c
index dc1cfa8ae..f4324f7af 100644
--- a/cogl/cogl-journal.c
+++ b/cogl/cogl-journal.c
@@ -301,7 +301,7 @@ _cogl_journal_flush_modelview_and_entries (CoglJournalEntry *batch_start,
     draw_flags |= COGL_DRAW_COLOR_ATTRIBUTE_IS_OPAQUE;
 
 #ifdef HAVE_COGL_GL
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_QUADS))
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUADS))
     {
       /* XXX: it's rather evil that we sneak in the GL_QUADS enum here... */
       _cogl_framebuffer_draw_attributes (framebuffer,
@@ -632,7 +632,7 @@ _cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
                         4,
                         COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
 
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_QUADS))
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUADS))
     state->indices = cogl_get_rectangle_indices (ctx, batch_len);
 
   /* We only create new Attributes when the stride within the
@@ -1050,7 +1050,7 @@ create_attribute_buffer (CoglJournal *journal,
   /* If CoglBuffers are being emulated with malloc then there's not
      really any point in using the pool so we'll just allocate the
      buffer directly */
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_VBOS))
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_VBOS))
     return cogl_attribute_buffer_new_with_size (ctx, n_bytes);
 
   vbo = journal->vbo_pool[journal->next_vbo_in_pool];
diff --git a/cogl/cogl-matrix-stack.c b/cogl/cogl-matrix-stack.c
index 877086e34..6438041ae 100644
--- a/cogl/cogl-matrix-stack.c
+++ b/cogl/cogl-matrix-stack.c
@@ -816,7 +816,7 @@ _cogl_matrix_flush_to_gl_builtin (CoglContext *ctx,
                                   CoglMatrix *matrix,
                                   CoglMatrixMode mode)
 {
-  g_assert ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED));
+  g_assert (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED));
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
   if (ctx->flushed_matrix_mode != mode)
@@ -856,7 +856,7 @@ _cogl_matrix_entry_flush_to_gl_builtins (CoglContext *ctx,
                                          CoglFramebuffer *framebuffer,
                                          CoglBool disable_flip)
 {
-  g_assert ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED));
+  g_assert (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED));
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
   {
diff --git a/cogl/cogl-onscreen.c b/cogl/cogl-onscreen.c
index cedb93cd9..cffbe3371 100644
--- a/cogl/cogl-onscreen.c
+++ b/cogl/cogl-onscreen.c
@@ -633,8 +633,8 @@ _cogl_framebuffer_winsys_update_size (CoglFramebuffer *framebuffer,
 
   cogl_framebuffer_set_viewport (framebuffer, 0, 0, width, height);
 
-  if (!(framebuffer->context->private_feature_flags &
-        COGL_PRIVATE_FEATURE_DIRTY_EVENTS))
+  if (!_cogl_has_private_feature (framebuffer->context,
+                                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS))
     _cogl_onscreen_queue_full_dirty (COGL_ONSCREEN (framebuffer));
 }
 
diff --git a/cogl/cogl-pipeline-state.c b/cogl/cogl-pipeline-state.c
index 02feb5137..44f917af0 100644
--- a/cogl/cogl-pipeline-state.c
+++ b/cogl/cogl-pipeline-state.c
@@ -1039,7 +1039,7 @@ cogl_pipeline_set_blend_constant (CoglPipeline *pipeline,
 
   _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
 
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_BLEND_CONSTANT))
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_BLEND_CONSTANT))
     return;
 
 #if defined(HAVE_COGL_GLES2) || defined(HAVE_COGL_GL)
diff --git a/cogl/cogl-pipeline.c b/cogl/cogl-pipeline.c
index d32584a8d..350cbf361 100644
--- a/cogl/cogl-pipeline.c
+++ b/cogl/cogl-pipeline.c
@@ -3095,8 +3095,8 @@ _cogl_pipeline_get_state_for_vertex_codegen (CoglContext *context)
    * one in the GLSL but we'll only do this if the point size is
    * non-zero. Whether or not the point size is zero is represented by
    * COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE */
-  if (!(context->private_feature_flags &
-        COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM))
+  if (!_cogl_has_private_feature
+      (context, COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM))
     state |= COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE;
 
   return state;
@@ -3127,7 +3127,7 @@ _cogl_pipeline_get_state_for_fragment_codegen (CoglContext *context)
                              COGL_PIPELINE_STATE_USER_SHADER |
                              COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS);
 
-  if (!(context->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEST))
+  if (!_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_ALPHA_TEST))
     state |= COGL_PIPELINE_STATE_ALPHA_FUNC;
 
   return state;
diff --git a/cogl/cogl-private.h b/cogl/cogl-private.h
index 5dee8e38c..e7d025b59 100644
--- a/cogl/cogl-private.h
+++ b/cogl/cogl-private.h
@@ -27,50 +27,52 @@
 #include <cogl/cogl-pipeline.h>
 
 #include "cogl-context.h"
-
+#include "cogl-flags.h"
 
 COGL_BEGIN_DECLS
 
 typedef enum
 {
-  COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE = 1L<<0,
-  COGL_PRIVATE_FEATURE_MESA_PACK_INVERT = 1L<<1,
-  COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT = 1L<<2,
-  COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES = 1L<<3,
-  COGL_PRIVATE_FEATURE_PBOS = 1L<<4,
-  COGL_PRIVATE_FEATURE_VBOS = 1L<<5,
-  COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL = 1L<<6,
-  COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL = 1L<<7,
-  COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888 = 1L<<8,
-  COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE = 1L<<9,
-  COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS = 1L<<10,
-  COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT = 1L<<11,
-  COGL_PRIVATE_FEATURE_ALPHA_TEST = 1L<<12,
-  COGL_PRIVATE_FEATURE_FORMAT_CONVERSION = 1L<<13,
-  COGL_PRIVATE_FEATURE_QUADS = 1L<<14,
-  COGL_PRIVATE_FEATURE_BLEND_CONSTANT = 1L<<15,
-  COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS = 1L<<16,
-  COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM = 1L<<17,
-  COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS = 1L<<18,
-  COGL_PRIVATE_FEATURE_ALPHA_TEXTURES = 1L<<19,
-  COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE = 1L<<20,
-  COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL = 1L<<21,
-  COGL_PRIVATE_FEATURE_ARBFP = 1L<<22,
-  COGL_PRIVATE_FEATURE_OES_EGL_SYNC = 1L<<23,
+  COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE,
+  COGL_PRIVATE_FEATURE_MESA_PACK_INVERT,
+  COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT,
+  COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES,
+  COGL_PRIVATE_FEATURE_PBOS,
+  COGL_PRIVATE_FEATURE_VBOS,
+  COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL,
+  COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL,
+  COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888,
+  COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE,
+  COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS,
+  COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT,
+  COGL_PRIVATE_FEATURE_ALPHA_TEST,
+  COGL_PRIVATE_FEATURE_FORMAT_CONVERSION,
+  COGL_PRIVATE_FEATURE_QUADS,
+  COGL_PRIVATE_FEATURE_BLEND_CONSTANT,
+  COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS,
+  COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM,
+  COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS,
+  COGL_PRIVATE_FEATURE_ALPHA_TEXTURES,
+  COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE,
+  COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL,
+  COGL_PRIVATE_FEATURE_ARBFP,
+  COGL_PRIVATE_FEATURE_OES_EGL_SYNC,
   /* If this is set then the winsys is responsible for queueing dirty
    * events. Otherwise a dirty event will be queued when the onscreen
    * is first allocated or when it is shown or resized */
-  COGL_PRIVATE_FEATURE_DIRTY_EVENTS = 1L<<24,
-  COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE = 1L<<25,
+  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+  COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE,
   /* These features let us avoid conditioning code based on the exact
    * driver being used and instead check for broad opengl feature
    * sets that can be shared by several GL apis */
-  COGL_PRIVATE_FEATURE_ANY_GL = 1L<<26,
-  COGL_PRIVATE_FEATURE_GL_FIXED = 1L<<27,
-  COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE = 1L<<28,
-  COGL_PRIVATE_FEATURE_GL_EMBEDDED = 1L<<29,
-  COGL_PRIVATE_FEATURE_GL_WEB = 1L<<30
-} CoglPrivateFeatureFlags;
+  COGL_PRIVATE_FEATURE_ANY_GL,
+  COGL_PRIVATE_FEATURE_GL_FIXED,
+  COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE,
+  COGL_PRIVATE_FEATURE_GL_EMBEDDED,
+  COGL_PRIVATE_FEATURE_GL_WEB,
+
+  COGL_N_PRIVATE_FEATURES
+} CoglPrivateFeature;
 
 /* Sometimes when evaluating pipelines, either during comparisons or
  * if calculating a hash value we need to tweak the evaluation
@@ -102,6 +104,9 @@ _cogl_push_source (CoglPipeline *pipeline, CoglBool enable_legacy);
 CoglBool
 _cogl_get_enable_legacy_state (void);
 
+#define _cogl_has_private_feature(ctx, feature) \
+  COGL_FLAGS_GET ((ctx)->private_features, (feature))
+
 /*
  * _cogl_pixel_format_get_bytes_per_pixel:
  * @format: a #CoglPixelFormat
diff --git a/cogl/cogl-renderer-private.h b/cogl/cogl-renderer-private.h
index 8b8d2bfed..23b5303d4 100644
--- a/cogl/cogl-renderer-private.h
+++ b/cogl/cogl-renderer-private.h
@@ -70,7 +70,8 @@ struct _CoglRenderer
 #endif
 
   CoglDriver driver;
-  CoglPrivateFeatureFlags private_feature_flags;
+  unsigned long private_features
+    [COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_N_PRIVATE_FEATURES)];
 #ifndef HAVE_DIRECTLY_LINKED_GL_LIBRARY
   GModule *libgl_module;
 #endif
diff --git a/cogl/cogl-renderer.c b/cogl/cogl-renderer.c
index 61cda6ff6..d2042fcf7 100644
--- a/cogl/cogl-renderer.c
+++ b/cogl/cogl-renderer.c
@@ -95,16 +95,17 @@ typedef struct _CoglDriverDescription
   CoglDriver id;
   const char *name;
   CoglRendererConstraint constraints;
-  CoglPrivateFeatureFlags private_feature_flags;
+  /* It would be nice to make this a pointer and then use a compound
+   * literal from C99 to initialise it but we probably can't get away
+   * with using C99 here. Instead we'll just use a fixed-size array.
+   * GCC should complain if someone adds an 8th feature to a
+   * driver. */
+  const CoglPrivateFeature private_features[8];
   const CoglDriverVtable *vtable;
   const CoglTextureDriver *texture_driver;
   const char *libgl_name;
 } CoglDriverDescription;
 
-_COGL_STATIC_ASSERT(sizeof (CoglPrivateFeatureFlags) <=
-                    sizeof (uint32_t),
-                    "Private feature flags don't fit in 32 bits");
-
 static CoglDriverDescription _cogl_drivers[] =
 {
 #ifdef HAVE_COGL_GL
@@ -112,9 +113,10 @@ static CoglDriverDescription _cogl_drivers[] =
     COGL_DRIVER_GL,
     "gl",
     0,
-    COGL_PRIVATE_FEATURE_ANY_GL |
-      COGL_PRIVATE_FEATURE_GL_FIXED |
+    { COGL_PRIVATE_FEATURE_ANY_GL,
+      COGL_PRIVATE_FEATURE_GL_FIXED,
       COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE,
+      -1 },
     &_cogl_driver_gl,
     &_cogl_texture_driver_gl,
     COGL_GL_LIBNAME,
@@ -123,8 +125,9 @@ static CoglDriverDescription _cogl_drivers[] =
     COGL_DRIVER_GL3,
     "gl3",
     0,
-    COGL_PRIVATE_FEATURE_ANY_GL |
+    { COGL_PRIVATE_FEATURE_ANY_GL,
       COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE,
+      -1 },
     &_cogl_driver_gl,
     &_cogl_texture_driver_gl,
     COGL_GL_LIBNAME,
@@ -135,9 +138,10 @@ static CoglDriverDescription _cogl_drivers[] =
     COGL_DRIVER_GLES2,
     "gles2",
     COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2,
-    COGL_PRIVATE_FEATURE_ANY_GL |
-      COGL_PRIVATE_FEATURE_GL_EMBEDDED |
+    { COGL_PRIVATE_FEATURE_ANY_GL,
+      COGL_PRIVATE_FEATURE_GL_EMBEDDED,
       COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE,
+      -1 },
     &_cogl_driver_gles,
     &_cogl_texture_driver_gles,
     COGL_GLES2_LIBNAME,
@@ -148,9 +152,10 @@ static CoglDriverDescription _cogl_drivers[] =
     COGL_DRIVER_GLES1,
     "gles1",
     0,
-    COGL_PRIVATE_FEATURE_ANY_GL |
-      COGL_PRIVATE_FEATURE_GL_EMBEDDED |
+    { COGL_PRIVATE_FEATURE_ANY_GL,
+      COGL_PRIVATE_FEATURE_GL_EMBEDDED,
       COGL_PRIVATE_FEATURE_GL_FIXED,
+      -1 },
     &_cogl_driver_gles,
     &_cogl_texture_driver_gles,
     COGL_GLES1_LIBNAME,
@@ -161,10 +166,11 @@ static CoglDriverDescription _cogl_drivers[] =
     COGL_DRIVER_WEBGL,
     "webgl",
     0,
-    COGL_PRIVATE_FEATURE_ANY_GL |
-      COGL_PRIVATE_FEATURE_GL_EMBEDDED |
-      COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE |
+    { COGL_PRIVATE_FEATURE_ANY_GL,
+      COGL_PRIVATE_FEATURE_GL_EMBEDDED,
+      COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE,
       COGL_PRIVATE_FEATURE_GL_WEB,
+      -1 },
     &_cogl_driver_gles,
     &_cogl_texture_driver_gles,
     NULL,
@@ -174,7 +180,7 @@ static CoglDriverDescription _cogl_drivers[] =
     COGL_DRIVER_NOP,
     "nop",
     0, /* constraints satisfied */
-    0, /* flags */
+    { -1 },
     &_cogl_driver_nop,
     NULL, /* texture driver */
     NULL /* libgl_name */
@@ -495,6 +501,7 @@ _cogl_renderer_choose_driver (CoglRenderer *renderer,
   const char *libgl_name;
   SatisfyConstraintsState state;
   const CoglDriverDescription *desc;
+  int i;
 
   if (!driver_name)
     driver_name = _cogl_config_driver;
@@ -569,12 +576,17 @@ _cogl_renderer_choose_driver (CoglRenderer *renderer,
   renderer->driver = desc->id;
   renderer->driver_vtable = desc->vtable;
   renderer->texture_driver = desc->texture_driver;
-  renderer->private_feature_flags = desc->private_feature_flags;
   libgl_name = desc->libgl_name;
 
+  memset(renderer->private_features, 0, sizeof (renderer->private_features));
+  for (i = 0; desc->private_features[i] != -1; i++)
+    COGL_FLAGS_SET (renderer->private_features,
+                    desc->private_features[i], TRUE);
+
 #ifndef HAVE_DIRECTLY_LINKED_GL_LIBRARY
 
-  if (renderer->private_feature_flags & COGL_PRIVATE_FEATURE_ANY_GL)
+  if (COGL_FLAGS_GET (renderer->private_features,
+                      COGL_PRIVATE_FEATURE_ANY_GL))
     {
       renderer->libgl_module = g_module_open (libgl_name,
                                               G_MODULE_BIND_LAZY);
diff --git a/cogl/cogl-sampler-cache.c b/cogl/cogl-sampler-cache.c
index 84bb81d3b..a914ed740 100644
--- a/cogl/cogl-sampler-cache.c
+++ b/cogl/cogl-sampler-cache.c
@@ -208,8 +208,8 @@ _cogl_sampler_cache_get_entry_gl (CoglSamplerCache *cache,
 
       entry = g_slice_dup (CoglSamplerCacheEntry, key);
 
-      if ((context->private_feature_flags &
-           COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
+      if (_cogl_has_private_feature (context,
+                                     COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
         {
           GE( context, glGenSamplers (1, &entry->sampler_object) );
 
@@ -329,8 +329,8 @@ hash_table_free_gl_cb (void *key,
   CoglContext *context = user_data;
   CoglSamplerCacheEntry *entry = value;
 
-  if ((context->private_feature_flags &
-       COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
+  if (_cogl_has_private_feature (context,
+                                 COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
     GE( context, glDeleteSamplers (1, &entry->sampler_object) );
 
   g_slice_free (CoglSamplerCacheEntry, entry);
diff --git a/cogl/cogl-texture-2d.c b/cogl/cogl-texture-2d.c
index c3682ee6e..174e141eb 100644
--- a/cogl/cogl-texture-2d.c
+++ b/cogl/cogl-texture-2d.c
@@ -268,9 +268,10 @@ _cogl_egl_texture_2d_new_from_image (CoglContext *ctx,
                             COGL_RENDERER_CONSTRAINT_USES_EGL,
                             NULL);
 
-  _COGL_RETURN_VAL_IF_FAIL (ctx->private_feature_flags &
-                        COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE,
-                        NULL);
+  _COGL_RETURN_VAL_IF_FAIL (_cogl_has_private_feature
+                            (ctx,
+                             COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE),
+                            NULL);
 
   if (ctx->driver_vtable->egl_texture_2d_new_from_image)
     return ctx->driver_vtable->egl_texture_2d_new_from_image (ctx,
diff --git a/cogl/cogl-texture-3d.c b/cogl/cogl-texture-3d.c
index 697b6c458..c4d4679e9 100644
--- a/cogl/cogl-texture-3d.c
+++ b/cogl/cogl-texture-3d.c
@@ -579,7 +579,7 @@ _cogl_texture_3d_pre_paint (CoglTexture *tex, CoglTexturePrePaintFlags flags)
       if (cogl_has_feature (ctx, COGL_FEATURE_ID_OFFSCREEN))
         _cogl_texture_gl_generate_mipmaps (tex);
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
-      else if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED)
+      else if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED))
         {
           _cogl_bind_gl_texture_transient (GL_TEXTURE_3D,
                                            tex_3d->gl_texture,
diff --git a/cogl/cogl-texture-rectangle.c b/cogl/cogl-texture-rectangle.c
index 80b627a00..9468369c2 100644
--- a/cogl/cogl-texture-rectangle.c
+++ b/cogl/cogl-texture-rectangle.c
@@ -398,8 +398,8 @@ cogl_texture_rectangle_new_from_foreign (CoglContext *ctx,
   /* Obtain texture parameters */
 
 #ifdef HAVE_COGL_GL
-  if ((ctx->private_feature_flags &
-       COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS))
+  if (_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS))
     {
       GLint val;
 
diff --git a/cogl/cogl-texture.c b/cogl/cogl-texture.c
index bb074dcce..1e9df8ccf 100644
--- a/cogl/cogl-texture.c
+++ b/cogl/cogl-texture.c
@@ -1068,7 +1068,7 @@ cogl_texture_get_data (CoglTexture *texture,
    * this case the driver will be faking the alpha textures with a
    * red-component texture and it won't swizzle to the correct format
    * while reading */
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) == 0)
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES))
     {
       if (texture_format == COGL_PIXEL_FORMAT_A_8)
         {
diff --git a/cogl/driver/gl/cogl-attribute-gl.c b/cogl/driver/gl/cogl-attribute-gl.c
index 7d1ce237b..a30d139f2 100644
--- a/cogl/driver/gl/cogl-attribute-gl.c
+++ b/cogl/driver/gl/cogl-attribute-gl.c
@@ -55,8 +55,8 @@ toggle_builtin_attribute_enabled_cb (int bit_num, void *user_data)
   ForeachChangedBitState *state = user_data;
   CoglContext *context = state->context;
 
-  _COGL_RETURN_VAL_IF_FAIL ((context->private_feature_flags &
-                             COGL_PRIVATE_FEATURE_GL_FIXED),
+  _COGL_RETURN_VAL_IF_FAIL (_cogl_has_private_feature
+                            (context, COGL_PRIVATE_FEATURE_GL_FIXED),
                             FALSE);
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
@@ -92,8 +92,8 @@ toggle_texcood_attribute_enabled_cb (int bit_num, void *user_data)
   ForeachChangedBitState *state = user_data;
   CoglContext *context = state->context;
 
-  _COGL_RETURN_VAL_IF_FAIL ((context->private_feature_flags &
-                             COGL_PRIVATE_FEATURE_GL_FIXED),
+  _COGL_RETURN_VAL_IF_FAIL (_cogl_has_private_feature
+                            (context, COGL_PRIVATE_FEATURE_GL_FIXED),
                             FALSE);
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
@@ -282,7 +282,7 @@ setup_legacy_buffered_attribute (CoglContext *ctx,
       break;
     case COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY:
 #ifdef COGL_PIPELINE_PROGEND_GLSL
-      if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE)
+      if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE))
         setup_generic_buffered_attribute (ctx, pipeline, attribute, base);
 #endif
       break;
@@ -299,7 +299,7 @@ setup_legacy_const_attribute (CoglContext *ctx,
 #ifdef COGL_PIPELINE_PROGEND_GLSL
   if (attribute->name_state->name_id == COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY)
     {
-      if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE)
+      if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE))
         setup_generic_const_attribute (ctx, pipeline, attribute);
     }
   else
diff --git a/cogl/driver/gl/cogl-clip-stack-gl.c b/cogl/driver/gl/cogl-clip-stack-gl.c
index e10141bd0..15b4d02b2 100644
--- a/cogl/driver/gl/cogl-clip-stack-gl.c
+++ b/cogl/driver/gl/cogl-clip-stack-gl.c
@@ -449,7 +449,7 @@ _cogl_clip_stack_gl_flush (CoglClipStack *stack,
   ctx->current_clip_stack = _cogl_clip_stack_ref (stack);
 
   has_clip_planes =
-    ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES;
+    _cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES);
 
   if (has_clip_planes)
     disable_clip_planes (ctx);
diff --git a/cogl/driver/gl/cogl-framebuffer-gl.c b/cogl/driver/gl/cogl-framebuffer-gl.c
index 9e23f8642..5749983da 100644
--- a/cogl/driver/gl/cogl-framebuffer-gl.c
+++ b/cogl/driver/gl/cogl-framebuffer-gl.c
@@ -327,8 +327,8 @@ _cogl_framebuffer_gl_flush_state (CoglFramebuffer *draw_buffer,
           /* NB: Currently we only take advantage of binding separate
            * read/write buffers for offscreen framebuffer blit
            * purposes.  */
-          _COGL_RETURN_IF_FAIL (ctx->private_feature_flags &
-                                COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT);
+          _COGL_RETURN_IF_FAIL (_cogl_has_private_feature
+                                (ctx, COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT));
           _COGL_RETURN_IF_FAIL (draw_buffer->type == COGL_FRAMEBUFFER_TYPE_OFFSCREEN);
           _COGL_RETURN_IF_FAIL (read_buffer->type == COGL_FRAMEBUFFER_TYPE_OFFSCREEN);
 
@@ -390,12 +390,11 @@ create_depth_texture (CoglContext *ctx,
   CoglPixelFormat format;
   CoglTexture2D *depth_texture;
 
-  if (ctx->private_feature_flags &
-      (COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL |
-       COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL))
-    {
-      format = COGL_PIXEL_FORMAT_DEPTH_24_STENCIL_8;
-    }
+  if (_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL) ||
+      _cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL))
+    format = COGL_PIXEL_FORMAT_DEPTH_24_STENCIL_8;
   else
     format = COGL_PIXEL_FORMAT_DEPTH_16;
 
@@ -476,15 +475,15 @@ try_creating_renderbuffers (CoglContext *ctx,
        * GL_OES_packed_depth_stencil doesn't allow GL_DEPTH_STENCIL to
        * be passed as an internal format to glRenderbufferStorage.
        */
-      if (ctx->private_feature_flags &
-          COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL)
+      if (_cogl_has_private_feature
+          (ctx, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL))
         format = GL_DEPTH_STENCIL;
       else
         {
           _COGL_RETURN_VAL_IF_FAIL (
-                                  ctx->private_feature_flags &
-                                  COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL,
-                                  NULL);
+            _cogl_has_private_feature (ctx,
+              COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL),
+            NULL);
           format = GL_DEPTH24_STENCIL8;
         }
 #endif
@@ -794,9 +793,10 @@ _cogl_offscreen_gl_allocate (CoglOffscreen *offscreen,
        /* NB: WebGL introduces a DEPTH_STENCIL_ATTACHMENT and doesn't
         * need an extension to handle _FLAG_DEPTH_STENCIL */
 #ifndef HAVE_COGL_WEBGL
-       (ctx->private_feature_flags
-        & (COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL |
-           COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL)) &&
+       (_cogl_has_private_feature
+        (ctx, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL) ||
+        _cogl_has_private_feature
+        (ctx, COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL)) &&
 #endif
        try_creating_fbo (ctx,
                          offscreen->texture,
@@ -955,8 +955,8 @@ _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer)
                                  COGL_FRAMEBUFFER_STATE_BIND);
 
 #ifdef HAVE_COGL_GL
-  if ((ctx->private_feature_flags &
-       COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS) &&
+  if (_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS) &&
       framebuffer->type == COGL_FRAMEBUFFER_TYPE_OFFSCREEN)
     {
       static const struct
@@ -1003,8 +1003,7 @@ _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer)
 
   /* If we don't have alpha textures then the alpha bits are actually
    * stored in the red component */
-  if ((ctx->private_feature_flags &
-       COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) == 0 &&
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
       framebuffer->type == COGL_FRAMEBUFFER_TYPE_OFFSCREEN &&
       framebuffer->format == COGL_PIXEL_FORMAT_A_8)
     {
@@ -1333,7 +1332,7 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
 
   /* NB: All offscreen rendering is done upside down so there is no need
    * to flip in this case... */
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_MESA_PACK_INVERT) &&
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_MESA_PACK_INVERT) &&
       (source & COGL_READ_PIXELS_NO_FLIP) == 0 &&
       !cogl_is_offscreen (framebuffer))
     {
@@ -1353,8 +1352,8 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
      GL_RGBA/GL_UNSIGNED_BYTE and convert if necessary. We also need
      to use this intermediate buffer if the rowstride has padding
      because GLES does not support setting GL_ROW_LENGTH */
-  if ((!(ctx->private_feature_flags &
-         COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT) &&
+  if ((!_cogl_has_private_feature
+       (ctx, COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT) &&
        (gl_format != GL_RGBA || gl_type != GL_UNSIGNED_BYTE ||
         cogl_bitmap_get_rowstride (bitmap) != 4 * width)) ||
       (required_format & ~COGL_PREMULT_BIT) != (format & ~COGL_PREMULT_BIT))
@@ -1365,8 +1364,8 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
       uint8_t *tmp_data;
       CoglBool succeeded;
 
-      if ((ctx->private_feature_flags &
-           COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT))
+      if (_cogl_has_private_feature
+          (ctx, COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT))
         read_format = required_format;
       else
         {
diff --git a/cogl/driver/gl/cogl-pipeline-fragend-glsl.c b/cogl/driver/gl/cogl-pipeline-fragend-glsl.c
index 18f1ff6f5..804538a96 100644
--- a/cogl/driver/gl/cogl-pipeline-fragend-glsl.c
+++ b/cogl/driver/gl/cogl-pipeline-fragend-glsl.c
@@ -1022,7 +1022,7 @@ _cogl_pipeline_fragend_glsl_end (CoglPipeline *pipeline,
                          "  cogl_color_out = cogl_color_in;\n");
 
 #if defined(HAVE_COGL_GLES2) || defined (HAVE_COGL_GL)
-      if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEST))
+      if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEST))
         add_alpha_test_snippet (pipeline, shader_state);
 #endif
 
diff --git a/cogl/driver/gl/cogl-pipeline-opengl.c b/cogl/driver/gl/cogl-pipeline-opengl.c
index 8cc527636..0222e2d3b 100644
--- a/cogl/driver/gl/cogl-pipeline-opengl.c
+++ b/cogl/driver/gl/cogl-pipeline-opengl.c
@@ -439,7 +439,7 @@ flush_depth_state (CoglContext *ctx,
       (ctx->depth_range_near_cache != depth_state->range_near ||
        ctx->depth_range_far_cache != depth_state->range_far))
     {
-      if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED)
+      if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_EMBEDDED))
         GE (ctx, glDepthRangef (depth_state->range_near,
                                 depth_state->range_far));
       else
@@ -492,7 +492,7 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state (
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
   /* On GLES2 we'll flush the color later */
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) &&
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED) &&
       !with_color_attrib)
     {
       if ((pipelines_difference & COGL_PIPELINE_STATE_COLOR) ||
@@ -571,7 +571,7 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state (
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
 
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEST))
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEST))
     {
       /* Under GLES2 the alpha function is implemented as part of the
          fragment shader */
@@ -692,8 +692,8 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state (
     }
 
 #ifdef HAVE_COGL_GL
-  if ((ctx->private_feature_flags &
-       COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE) &&
+  if (_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE) &&
       (pipelines_difference & COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE))
     {
       unsigned long state = COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE;
@@ -730,7 +730,7 @@ get_max_activateable_texture_units (void)
       int i;
 
 #ifdef HAVE_COGL_GL
-      if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED))
+      if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_EMBEDDED))
         {
           /* GL_MAX_TEXTURE_COORDS is provided for both GLSL and ARBfp. It
              defines the number of texture coordinates that can be
@@ -753,8 +753,8 @@ get_max_activateable_texture_units (void)
 #endif /* HAVE_COGL_GL */
 
 #ifdef HAVE_COGL_GLES2
-      if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED &&
-          ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE)
+      if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_EMBEDDED) &&
+          _cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE))
         {
           GE (ctx, glGetIntegerv (GL_MAX_VERTEX_ATTRIBS, values + n_values));
           /* Two of the vertex attribs need to be used for the position
@@ -767,7 +767,7 @@ get_max_activateable_texture_units (void)
 #endif
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
-      if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED)
+      if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED))
         {
           /* GL_MAX_TEXTURE_UNITS defines the number of units that are
              usable from the fixed function pipeline, therefore it isn't
@@ -897,7 +897,7 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data)
     }
 
   if ((layers_difference & COGL_PIPELINE_LAYER_STATE_SAMPLER) &&
-      (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
+      _cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
     {
       const CoglSamplerCacheEntry *sampler_state;
 
@@ -912,7 +912,7 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data)
    * glsl progend.
    */
 #if defined (HAVE_COGL_GLES) || defined (HAVE_COGL_GL)
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) &&
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED) &&
       (layers_difference & COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS))
     {
       CoglPipelineState change = COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS;
@@ -1454,7 +1454,7 @@ done:
 
   /* Handle the fact that OpenGL associates texture filter and wrap
    * modes with the texture objects not the texture units... */
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS))
     foreach_texture_unit_update_filter_and_wrap_modes ();
 
   /* If this pipeline has more than one layer then we always need
diff --git a/cogl/driver/gl/cogl-pipeline-progend-fixed.c b/cogl/driver/gl/cogl-pipeline-progend-fixed.c
index dc2f63db8..504c8ac65 100644
--- a/cogl/driver/gl/cogl-pipeline-progend-fixed.c
+++ b/cogl/driver/gl/cogl-pipeline-progend-fixed.c
@@ -48,7 +48,7 @@ _cogl_pipeline_progend_fixed_start (CoglPipeline *pipeline)
   if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_FIXED)))
     return FALSE;
 
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED))
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED))
     return FALSE;
 
   /* Vertex snippets are only supported in the GLSL fragend */
diff --git a/cogl/driver/gl/cogl-pipeline-progend-glsl.c b/cogl/driver/gl/cogl-pipeline-progend-glsl.c
index d59e74859..74849793d 100644
--- a/cogl/driver/gl/cogl-pipeline-progend-glsl.c
+++ b/cogl/driver/gl/cogl-pipeline-progend-glsl.c
@@ -72,7 +72,7 @@ typedef struct
 
   /* This builtin is only necessary if the following private feature
    * is not implemented in the driver */
-  CoglPrivateFeatureFlags feature_replacement;
+  CoglPrivateFeature feature_replacement;
 } BuiltinUniformData;
 
 static BuiltinUniformData builtin_uniforms[] =
@@ -441,8 +441,8 @@ update_builtin_uniforms (CoglContext *context,
     return;
 
   for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++)
-    if ((context->private_feature_flags &
-         builtin_uniforms[i].feature_replacement) == 0 &&
+    if (!_cogl_has_private_feature (context,
+                                    builtin_uniforms[i].feature_replacement) &&
         (program_state->dirty_builtin_uniforms & (1 << i)) &&
         program_state->builtin_uniform_locations[i] != -1)
       builtin_uniforms[i].update_func (pipeline,
@@ -790,8 +790,8 @@ _cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline,
       clear_flushed_matrix_stacks (program_state);
 
       for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++)
-        if ((ctx->private_feature_flags &
-             builtin_uniforms[i].feature_replacement) == 0)
+        if (!_cogl_has_private_feature
+            (ctx, builtin_uniforms[i].feature_replacement))
           GE_RET( program_state->builtin_uniform_locations[i], ctx,
                   glGetUniformLocation (gl_program,
                                         builtin_uniforms[i].uniform_name) );
@@ -847,8 +847,8 @@ _cogl_pipeline_progend_glsl_pre_change_notify (CoglPipeline *pipeline,
       int i;
 
       for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++)
-        if ((ctx->private_feature_flags &
-             builtin_uniforms[i].feature_replacement) == 0 &&
+        if (!_cogl_has_private_feature
+            (ctx, builtin_uniforms[i].feature_replacement) &&
             (change & builtin_uniforms[i].change))
           {
             CoglPipelineProgramState *program_state
diff --git a/cogl/driver/gl/cogl-pipeline-vertend-glsl.c b/cogl/driver/gl/cogl-pipeline-vertend-glsl.c
index e4f91d954..a702a934d 100644
--- a/cogl/driver/gl/cogl-pipeline-vertend-glsl.c
+++ b/cogl/driver/gl/cogl-pipeline-vertend-glsl.c
@@ -295,8 +295,8 @@ _cogl_pipeline_vertend_glsl_start (CoglPipeline *pipeline,
   if (cogl_pipeline_get_per_vertex_point_size (pipeline))
     g_string_append (shader_state->header,
                      "attribute float cogl_point_size_in;\n");
-  else if (!(ctx->private_feature_flags &
-            COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM))
+  else if (!_cogl_has_private_feature
+           (ctx, COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM))
     {
       /* There is no builtin uniform for the point size on GLES2 so we
          need to copy it from the custom uniform in the vertex shader
@@ -532,8 +532,8 @@ _cogl_pipeline_vertend_glsl_end (CoglPipeline *pipeline,
     }
 
 #ifdef HAVE_COGL_GL
-  if ((ctx->private_feature_flags &
-       COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM) &&
+  if (_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM) &&
       (pipelines_difference & COGL_PIPELINE_STATE_POINT_SIZE))
     {
       CoglPipeline *authority =
@@ -641,8 +641,8 @@ UNIT_TEST (check_point_size_shader,
    * size */
   if (shader_states[0])
     {
-      if ((test_ctx->private_feature_flags &
-           COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM))
+      if (_cogl_has_private_feature
+          (test_ctx, COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM))
         g_assert (shader_states[0] == shader_states[1]);
       else
         g_assert (shader_states[0] != shader_states[1]);
diff --git a/cogl/driver/gl/cogl-texture-2d-gl.c b/cogl/driver/gl/cogl-texture-2d-gl.c
index 2a79f67af..b2829afb1 100644
--- a/cogl/driver/gl/cogl-texture-2d-gl.c
+++ b/cogl/driver/gl/cogl-texture-2d-gl.c
@@ -384,8 +384,8 @@ cogl_texture_2d_new_from_foreign (CoglContext *ctx,
      (only level 0 we are interested in) */
 
 #ifdef HAVE_COGL_GL
-  if ((ctx->private_feature_flags &
-       COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS))
+  if (_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS))
     {
       GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_2D, 0,
                                          GL_TEXTURE_COMPRESSED,
diff --git a/cogl/driver/gl/cogl-texture-gl.c b/cogl/driver/gl/cogl-texture-gl.c
index ccf526c1d..502224e08 100644
--- a/cogl/driver/gl/cogl-texture-gl.c
+++ b/cogl/driver/gl/cogl-texture-gl.c
@@ -105,7 +105,7 @@ _cogl_texture_gl_maybe_update_max_level (CoglTexture *texture,
 #ifdef HAVE_COGL_GL
   CoglContext *ctx = texture->context;
 
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL) &&
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL) &&
       texture->max_level < max_level)
     {
       CoglContext *ctx = texture->context;
diff --git a/cogl/driver/gl/gl/cogl-driver-gl.c b/cogl/driver/gl/gl/cogl-driver-gl.c
index 5f615f56e..2ce78d811 100644
--- a/cogl/driver/gl/gl/cogl-driver-gl.c
+++ b/cogl/driver/gl/gl/cogl-driver-gl.c
@@ -105,8 +105,8 @@ _cogl_driver_pixel_format_to_gl (CoglContext *context,
       /* If the driver doesn't natively support alpha textures then we
        * will use a red component texture with a swizzle to implement
        * the texture */
-      if ((context->private_feature_flags &
-           COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) == 0)
+      if (_cogl_has_private_feature
+          (context, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) == 0)
         {
           glintformat = GL_RED;
           glformat = GL_RED;
@@ -356,10 +356,12 @@ static CoglBool
 _cogl_driver_update_features (CoglContext *ctx,
                               CoglError **error)
 {
-  CoglPrivateFeatureFlags private_flags = 0;
   CoglFeatureFlags flags = 0;
+  unsigned long private_features
+    [COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_N_PRIVATE_FEATURES)] = { 0 };
   char **gl_extensions;
   int gl_major = 0, gl_minor = 0;
+  int i;
 
   /* We have to special case getting the pointer to the glGetString*
      functions because we need to use them to determine what functions
@@ -453,17 +455,21 @@ _cogl_driver_update_features (CoglContext *ctx,
     }
 
   if (_cogl_check_extension ("GL_MESA_pack_invert", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_MESA_PACK_INVERT;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_MESA_PACK_INVERT, TRUE);
 
   if (ctx->glGenRenderbuffers)
     {
       flags |= COGL_FEATURE_OFFSCREEN;
       COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_OFFSCREEN, TRUE);
-      private_flags |= COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS;
+      COGL_FLAGS_SET (private_features,
+                      COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS,
+                      TRUE);
     }
 
   if (ctx->glBlitFramebuffer)
-    private_flags |= COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT, TRUE);
 
   if (ctx->glRenderbufferStorageMultisampleIMG)
     {
@@ -481,11 +487,12 @@ _cogl_driver_update_features (CoglContext *ctx,
 
   if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 1) ||
       _cogl_check_extension ("GL_EXT_pixel_buffer_object", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_PBOS;
+    COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_PBOS, TRUE);
 
   if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 1, 4) ||
       _cogl_check_extension ("GL_EXT_blend_color", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_BLEND_CONSTANT;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_BLEND_CONSTANT, TRUE);
 
   if (ctx->glGenPrograms)
     {
@@ -545,7 +552,7 @@ _cogl_driver_update_features (CoglContext *ctx,
 
   if (ctx->glGenBuffers)
     {
-      private_flags |= COGL_PRIVATE_FEATURE_VBOS;
+      COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_VBOS, TRUE);
       flags |= (COGL_FEATURE_MAP_BUFFER_FOR_READ |
                 COGL_FEATURE_MAP_BUFFER_FOR_WRITE);
       COGL_FLAGS_SET (ctx->features,
@@ -568,19 +575,22 @@ _cogl_driver_update_features (CoglContext *ctx,
     }
 
   if (ctx->glEGLImageTargetTexture2D)
-    private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE, TRUE);
 
   if (_cogl_check_extension ("GL_EXT_packed_depth_stencil", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL, TRUE);
 
   if (ctx->glGenSamplers)
-    private_flags |= COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS;
-
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS, TRUE);
 
   if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 3, 3) ||
       _cogl_check_extension ("GL_ARB_texture_swizzle", gl_extensions) ||
       _cogl_check_extension ("GL_EXT_texture_swizzle", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE, TRUE);
 
   /* The per-vertex point size is only available via GLSL with the
    * gl_PointSize builtin. This is only available in GL 2.0 (not the
@@ -590,7 +600,8 @@ _cogl_driver_update_features (CoglContext *ctx,
       COGL_FLAGS_SET (ctx->features,
                       COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE,
                       TRUE);
-      private_flags |= COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE;
+      COGL_FLAGS_SET (private_features,
+                      COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE, TRUE);
     }
 
   if (ctx->driver == COGL_DRIVER_GL)
@@ -598,35 +609,43 @@ _cogl_driver_update_features (CoglContext *ctx,
       int max_clip_planes = 0;
 
       /* Features which are not available in GL 3 */
-      private_flags |= (COGL_PRIVATE_FEATURE_GL_FIXED |
-                        COGL_PRIVATE_FEATURE_ALPHA_TEST |
-                        COGL_PRIVATE_FEATURE_QUADS |
-                        COGL_PRIVATE_FEATURE_ALPHA_TEXTURES);
+      COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_GL_FIXED, TRUE);
+      COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ALPHA_TEST, TRUE);
+      COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_QUADS, TRUE);
+      COGL_FLAGS_SET (private_features,
+                      COGL_PRIVATE_FEATURE_ALPHA_TEXTURES, TRUE);
 
       GE( ctx, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) );
       if (max_clip_planes >= 4)
-        private_flags |= COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES;
+        COGL_FLAGS_SET (private_features,
+                        COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES, TRUE);
     }
 
-  private_flags |= (COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT |
-                    COGL_PRIVATE_FEATURE_ANY_GL |
-                    COGL_PRIVATE_FEATURE_FORMAT_CONVERSION |
-                    COGL_PRIVATE_FEATURE_BLEND_CONSTANT |
-                    COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM |
-                    COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS |
-                    COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT, TRUE);
+  COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ANY_GL, TRUE);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_FORMAT_CONVERSION, TRUE);
+  COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_BLEND_CONSTANT, TRUE);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM, TRUE);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS, TRUE);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL, TRUE);
 
   if (ctx->glFenceSync)
     COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_FENCE, TRUE);
 
   /* Cache features */
-  ctx->private_feature_flags |= private_flags;
+  for (i = 0; i < G_N_ELEMENTS (private_features); i++)
+    ctx->private_features[i] |= private_features[i];
   ctx->feature_flags |= flags;
 
   g_strfreev (gl_extensions);
 
-  if ((private_flags & (COGL_PRIVATE_FEATURE_ALPHA_TEXTURES |
-                        COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE)) == 0)
+  if (!COGL_FLAGS_GET (private_features, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
+      !COGL_FLAGS_GET (private_features, COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE))
     {
       _cogl_set_error (error,
                        COGL_DRIVER_ERROR,
diff --git a/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c b/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c
index 45a9f28a8..61f478bd2 100644
--- a/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c
+++ b/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c
@@ -51,7 +51,7 @@ _cogl_pipeline_progend_fixed_arbfp_start (CoglPipeline *pipeline)
   if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_FIXED)))
     return FALSE;
 
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED))
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED))
     return FALSE;
 
   /* Vertex snippets are only supported in the GLSL fragend */
diff --git a/cogl/driver/gl/gl/cogl-texture-driver-gl.c b/cogl/driver/gl/gl/cogl-texture-driver-gl.c
index 46da7f62f..62ae88b87 100644
--- a/cogl/driver/gl/gl/cogl-texture-driver-gl.c
+++ b/cogl/driver/gl/gl/cogl-texture-driver-gl.c
@@ -74,7 +74,8 @@ _cogl_texture_driver_gen (CoglContext *ctx,
        * "complete".
        */
 #ifdef HAVE_COGL_GL
-      if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL))
+      if (_cogl_has_private_feature
+          (ctx, COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL))
         GE( ctx, glTexParameteri (gl_target, GL_TEXTURE_MAX_LEVEL, 0));
 #endif
 
@@ -96,9 +97,8 @@ _cogl_texture_driver_gen (CoglContext *ctx,
   /* If the driver doesn't support alpha textures directly then we'll
    * fake them by setting the swizzle parameters */
   if (internal_format == COGL_PIXEL_FORMAT_A_8 &&
-      (ctx->private_feature_flags & (COGL_PRIVATE_FEATURE_ALPHA_TEXTURES |
-                                     COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE)) ==
-      COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE)
+      !_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
+      _cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE))
     {
       static const GLint red_swizzle[] = { GL_ZERO, GL_ZERO, GL_ZERO, GL_RED };
 
diff --git a/cogl/driver/gl/gles/cogl-driver-gles.c b/cogl/driver/gl/gles/cogl-driver-gles.c
index 8e798aff9..4783a7eef 100644
--- a/cogl/driver/gl/gles/cogl-driver-gles.c
+++ b/cogl/driver/gl/gles/cogl-driver-gles.c
@@ -84,8 +84,8 @@ _cogl_driver_pixel_format_to_gl (CoglContext *context,
     case COGL_PIXEL_FORMAT_BGRA_8888:
     case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
       /* There is an extension to support this format */
-      if ((context->private_feature_flags &
-           COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888))
+      if (_cogl_has_private_feature
+          (context,  COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888))
         {
           /* For some reason the extension says you have to specify
              BGRA for the internal format too */
@@ -190,9 +190,11 @@ static CoglBool
 _cogl_driver_update_features (CoglContext *context,
                               CoglError **error)
 {
-  CoglPrivateFeatureFlags private_flags = 0;
+  unsigned long private_features
+    [COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_N_PRIVATE_FEATURES)] = { 0 };
   CoglFeatureFlags flags = 0;
   char **gl_extensions;
+  int i;
 
   /* We have to special case getting the pointer to the glGetString
      function because we need to use it to determine what functions we
@@ -239,7 +241,8 @@ _cogl_driver_update_features (CoglContext *context,
       int max_clip_planes;
       GE( context, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) );
       if (max_clip_planes >= 4)
-        private_flags |= COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES;
+        COGL_FLAGS_SET (private_features,
+                        COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES, TRUE);
     }
 #endif
 
@@ -260,16 +263,20 @@ _cogl_driver_update_features (CoglContext *context,
       COGL_FLAGS_SET (context->features,
                       COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE, TRUE);
 
-      private_flags |= COGL_PRIVATE_FEATURE_BLEND_CONSTANT;
+      COGL_FLAGS_SET (private_features,
+                      COGL_PRIVATE_FEATURE_BLEND_CONSTANT, TRUE);
     }
   else if (context->driver == COGL_DRIVER_GLES1)
-    private_flags |= (COGL_PRIVATE_FEATURE_GL_FIXED |
-                      COGL_PRIVATE_FEATURE_ALPHA_TEST |
-                      COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM);
+    {
+      COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_GL_FIXED, TRUE);
+      COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ALPHA_TEST, TRUE);
+      COGL_FLAGS_SET (private_features,
+                      COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM, TRUE);
+    }
 
-  private_flags |= (COGL_PRIVATE_FEATURE_VBOS |
-                    COGL_PRIVATE_FEATURE_ANY_GL |
-                    COGL_PRIVATE_FEATURE_ALPHA_TEXTURES);
+  COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_VBOS, TRUE);
+  COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ANY_GL, TRUE);
+  COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES, TRUE);
 
   /* Both GLES 1.1 and GLES 2.0 support point sprites in core */
   flags |= COGL_FEATURE_POINT_SPRITE;
@@ -282,7 +289,8 @@ _cogl_driver_update_features (CoglContext *context,
     }
 
   if (context->glBlitFramebuffer)
-    private_flags |= COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT, TRUE);
 
   if (_cogl_check_extension ("GL_OES_element_index_uint", gl_extensions))
     {
@@ -338,25 +346,30 @@ _cogl_driver_update_features (CoglContext *context,
     }
 
   if (context->glEGLImageTargetTexture2D)
-    private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE, TRUE);
 
   if (_cogl_check_extension ("GL_OES_packed_depth_stencil", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL, TRUE);
 
   if (_cogl_check_extension ("GL_EXT_texture_format_BGRA8888", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888, TRUE);
 
   if (_cogl_check_extension ("GL_EXT_unpack_subimage", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE;
+    COGL_FLAGS_SET (private_features,
+                    COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE, TRUE);
 
   /* A nameless vendor implemented the extension, but got the case wrong
    * per the spec. */
   if (_cogl_check_extension ("GL_OES_EGL_sync", gl_extensions) ||
       _cogl_check_extension ("GL_OES_egl_sync", gl_extensions))
-    private_flags |= COGL_PRIVATE_FEATURE_OES_EGL_SYNC;
+    COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_OES_EGL_SYNC, TRUE);
 
   /* Cache features */
-  context->private_feature_flags |= private_flags;
+  for (i = 0; i < G_N_ELEMENTS (private_features); i++)
+    context->private_features[i] |= private_features[i];
   context->feature_flags |= flags;
 
   g_strfreev (gl_extensions);
diff --git a/cogl/driver/gl/gles/cogl-texture-driver-gles.c b/cogl/driver/gl/gles/cogl-texture-driver-gles.c
index 4162dbc05..fd1320dea 100644
--- a/cogl/driver/gl/gles/cogl-texture-driver-gles.c
+++ b/cogl/driver/gl/gles/cogl-texture-driver-gles.c
@@ -102,7 +102,7 @@ prep_gl_for_pixels_upload_full (CoglContext *ctx,
                                 int pixels_src_y,
                                 int pixels_bpp)
 {
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE))
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE))
     {
       GE( ctx, glPixelStorei (GL_UNPACK_ROW_LENGTH,
                               pixels_rowstride / pixels_bpp) );
@@ -153,7 +153,7 @@ prepare_bitmap_alignment_for_upload (CoglContext *ctx,
   int width = cogl_bitmap_get_width (src_bmp);
   int alignment = 1;
 
-  if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE) ||
+  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE) ||
       src_rowstride == 0)
     return cogl_object_ref (src_bmp);
 
@@ -205,7 +205,7 @@ _cogl_texture_driver_upload_subregion_to_gl (CoglContext *ctx,
   /* If we have the GL_EXT_unpack_subimage extension then we can
      upload from subregions directly. Otherwise we may need to copy
      the bitmap */
-  if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE) &&
+  if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE) &&
       (src_x != 0 || src_y != 0 ||
        width != cogl_bitmap_get_width (source_bmp) ||
        height != cogl_bitmap_get_height (source_bmp)))
diff --git a/cogl/driver/nop/cogl-driver-nop.c b/cogl/driver/nop/cogl-driver-nop.c
index 7a782f9cf..b5f71b0c2 100644
--- a/cogl/driver/nop/cogl-driver-nop.c
+++ b/cogl/driver/nop/cogl-driver-nop.c
@@ -43,7 +43,7 @@ _cogl_driver_update_features (CoglContext *ctx,
 {
   /* _cogl_gpu_info_init (ctx, &ctx->gpu); */
 
-  ctx->private_feature_flags = 0;
+  memset (ctx->private_features, 0, sizeof (ctx->private_features));
   ctx->feature_flags = 0;
 
   return TRUE;
diff --git a/cogl/winsys/cogl-winsys-egl-wayland.c b/cogl/winsys/cogl-winsys-egl-wayland.c
index 628c348d5..bb3755d09 100644
--- a/cogl/winsys/cogl-winsys-egl-wayland.c
+++ b/cogl/winsys/cogl-winsys-egl-wayland.c
@@ -427,7 +427,9 @@ _cogl_winsys_egl_context_init (CoglContext *context,
    * delays setting the surface type until the next buffer is attached
    * so attaching a buffer before setting the type would not cause
    * anything to be displayed */
-  context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
+  COGL_FLAGS_SET (context->private_features,
+                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+                  TRUE);
 
   return TRUE;
 }
diff --git a/cogl/winsys/cogl-winsys-egl-x11.c b/cogl/winsys/cogl-winsys-egl-x11.c
index f5f7bc25d..a289d01f0 100644
--- a/cogl/winsys/cogl-winsys-egl-x11.c
+++ b/cogl/winsys/cogl-winsys-egl-x11.c
@@ -322,7 +322,9 @@ _cogl_winsys_egl_context_init (CoglContext *context,
 
   /* We'll manually handle queueing dirty events in response to
    * Expose events from X */
-  context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
+  COGL_FLAGS_SET (context->private_features,
+                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+                  TRUE);
 
   return TRUE;
 }
@@ -705,8 +707,8 @@ _cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
 
   if (!(egl_renderer->private_features &
         COGL_EGL_WINSYS_FEATURE_EGL_IMAGE_FROM_X11_PIXMAP) ||
-      !(ctx->private_feature_flags &
-        COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE))
+      !_cogl_has_private_feature
+      (ctx, COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE))
     {
       tex_pixmap->winsys = NULL;
       return FALSE;
diff --git a/cogl/winsys/cogl-winsys-egl.c b/cogl/winsys/cogl-winsys-egl.c
index 8f5acf1cd..cac001e5a 100644
--- a/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/winsys/cogl-winsys-egl.c
@@ -505,7 +505,7 @@ _cogl_winsys_context_init (CoglContext *context, CoglError **error)
     }
 
   if ((egl_renderer->private_features & COGL_EGL_WINSYS_FEATURE_FENCE_SYNC) &&
-      (context->private_feature_flags & COGL_PRIVATE_FEATURE_OES_EGL_SYNC))
+      _cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_OES_EGL_SYNC))
     COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_FENCE, TRUE);
 
   /* NB: We currently only support creating standalone GLES2 contexts
diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c
index 8395ed842..04af8d4b9 100644
--- a/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/winsys/cogl-winsys-glx.c
@@ -857,7 +857,9 @@ update_winsys_features (CoglContext *context, CoglError **error)
 
   /* We'll manually handle queueing dirty events in response to
    * Expose events from X */
-  context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
+  COGL_FLAGS_SET (context->private_features,
+                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+                  TRUE);
 
   return TRUE;
 }
diff --git a/cogl/winsys/cogl-winsys-sdl.c b/cogl/winsys/cogl-winsys-sdl.c
index 75b7edd8c..739995a6e 100644
--- a/cogl/winsys/cogl-winsys-sdl.c
+++ b/cogl/winsys/cogl-winsys-sdl.c
@@ -315,7 +315,9 @@ _cogl_winsys_context_init (CoglContext *context, CoglError **error)
 
   /* We'll manually handle queueing dirty events in response to
    * SDL_VIDEOEXPOSE events */
-  context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
+  COGL_FLAGS_SET (context->private_features,
+                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+                  TRUE);
 
   return _cogl_context_update_features (context, error);
 }
diff --git a/cogl/winsys/cogl-winsys-sdl2.c b/cogl/winsys/cogl-winsys-sdl2.c
index 58666cbdd..a89179eae 100644
--- a/cogl/winsys/cogl-winsys-sdl2.c
+++ b/cogl/winsys/cogl-winsys-sdl2.c
@@ -398,7 +398,9 @@ _cogl_winsys_context_init (CoglContext *context, CoglError **error)
 
   /* We'll manually handle queueing dirty events in response to
    * SDL_WINDOWEVENT_EXPOSED events */
-  context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
+  COGL_FLAGS_SET (context->private_features,
+                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+                  TRUE);
 
   _cogl_renderer_add_native_filter (renderer,
                                     (CoglNativeFilterFunc) sdl_event_filter_cb,
diff --git a/cogl/winsys/cogl-winsys-wgl.c b/cogl/winsys/cogl-winsys-wgl.c
index 6e789d77a..3c80db59d 100644
--- a/cogl/winsys/cogl-winsys-wgl.c
+++ b/cogl/winsys/cogl-winsys-wgl.c
@@ -708,7 +708,9 @@ update_winsys_features (CoglContext *context, CoglError **error)
 
   /* We'll manually handle queueing dirty events in response to
    * WM_PAINT messages */
-  context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
+  COGL_FLAGS_SET (context->private_features,
+                  COGL_PRIVATE_FEATURE_DIRTY_EVENTS,
+                  TRUE);
 
   return TRUE;
 }