devPrivates rework: since API is already broken, switch everything

over to new system.

Need to update documentation and address some remaining vestiges of
old system such as CursorRec structure, fb "offman" structure, and
FontRec privates.

6 files changed, 47 insertions, 497 deletions

diff --git a/render/animcur.c b/render/animcur.c
index 1f25e79d0..444d70645 100644
--- a/render/animcur.c
+++ b/render/animcur.c
@@ -87,14 +87,14 @@ static CursorBits   animCursorBits = {
     empty, empty, 2, 1, 1, 0, 0, 1
 };
 
-static int AnimCurScreenPrivateIndex = -1;
 static int AnimCurGeneration;
+static DevPrivateKey AnimCurScreenPrivateKey = &AnimCurScreenPrivateKey;
 
 #define IsAnimCur(c)	    ((c)->bits == &animCursorBits)
 #define GetAnimCur(c)	    ((AnimCurPtr) ((c) + 1))
-#define GetAnimCurScreen(s) ((AnimCurScreenPtr) ((s)->devPrivates[AnimCurScreenPrivateIndex].ptr))
-#define GetAnimCurScreenIfSet(s) ((AnimCurScreenPrivateIndex != -1) ? GetAnimCurScreen(s) : NULL)
-#define SetAnimCurScreen(s,p) ((s)->devPrivates[AnimCurScreenPrivateIndex].ptr = (pointer) (p))
+#define GetAnimCurScreen(s) ((AnimCurScreenPtr)dixLookupPrivate(&(s)->devPrivates, AnimCurScreenPrivateKey))
+#define GetAnimCurScreenIfSet(s) GetAnimCurScreen(s)
+#define SetAnimCurScreen(s,p) dixSetPrivate(&(s)->devPrivates, AnimCurScreenPrivateKey, p)
 
 #define Wrap(as,s,elt,func) (((as)->elt = (s)->elt), (s)->elt = func)
 #define Unwrap(as,s,elt)    ((s)->elt = (as)->elt)
@@ -128,8 +128,6 @@ AnimCurCloseScreen (int index, ScreenPtr pScreen)
     SetAnimCurScreen(pScreen,0);
     ret = (*pScreen->CloseScreen) (index, pScreen);
     xfree (as);
-    if (index == 0)
-	AnimCurScreenPrivateIndex = -1;
     return ret;
 }
 
@@ -324,9 +322,6 @@ AnimCurInit (ScreenPtr pScreen)
 
     if (AnimCurGeneration != serverGeneration)
     {
-	AnimCurScreenPrivateIndex = AllocateScreenPrivateIndex ();
-	if (AnimCurScreenPrivateIndex < 0)
-	    return FALSE;
 	AnimCurGeneration = serverGeneration;
 	animCurState.pCursor = 0;
 	animCurState.pScreen = 0;
diff --git a/render/glyph.c b/render/glyph.c
index 583a52ba3..cb1534d6e 100644
--- a/render/glyph.c
+++ b/render/glyph.c
@@ -81,220 +81,18 @@ static const CARD8	glyphDepths[GlyphFormatNum] = { 1, 4, 8, 16, 32 };
 
 static GlyphHashRec	globalGlyphs[GlyphFormatNum];
 
-static int	globalTotalGlyphPrivateSize = 0;
-
-static int	glyphPrivateCount = 0;
-
-void
-ResetGlyphPrivates (void)
-{
-    glyphPrivateCount = 0;
-}
-
-int
-AllocateGlyphPrivateIndex (void)
-{
-    return glyphPrivateCount++;
-}
-
-Bool
-AllocateGlyphPrivate (ScreenPtr pScreen,
-		      int	index2,
-		      unsigned	amount)
-{
-    PictureScreenPtr ps;
-    unsigned	     oldamount;
-
-    ps = GetPictureScreenIfSet (pScreen);
-    if (!ps)
-	return FALSE;
-
-    /* Round up sizes for proper alignment */
-    amount = ((amount + (sizeof (DevUnion) - 1)) / sizeof (DevUnion)) *
-	sizeof (DevUnion);
-
-    if (index2 >= ps->glyphPrivateLen)
-    {
-	unsigned *nsizes;
-	nsizes = (unsigned *) xrealloc (ps->glyphPrivateSizes,
-					(index2 + 1) * sizeof (unsigned));
-	if (!nsizes)
-	    return FALSE;
-	
-	while (ps->glyphPrivateLen <= index2)
-	{
-	    nsizes[ps->glyphPrivateLen++] = 0;
-	    ps->totalGlyphPrivateSize += sizeof (DevUnion);
-	}
-	ps->glyphPrivateSizes = nsizes;
-    }
-    oldamount = ps->glyphPrivateSizes[index2];
-    if (amount > oldamount)
-    {
-	ps->glyphPrivateSizes[index2] = amount;
-	ps->totalGlyphPrivateSize += (amount - oldamount);
-    }
-    ps->totalGlyphPrivateSize = BitmapBytePad (ps->totalGlyphPrivateSize * 8);
-    
-    return TRUE;
-}
-
 static void
-SetGlyphScreenPrivateOffsets (void)
+FreeGlyphPrivates (GlyphPtr glyph)
 {
-    PictureScreenPtr ps;
-    int		     offset = 0;
-    int		     i;
+    ScreenPtr pScreen;
+    int i;
 
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ps = GetPictureScreenIfSet (screenInfo.screens[i]);
-	if (ps && ps->totalGlyphPrivateSize)
-	{
-	    ps->glyphPrivateOffset = offset;
-	    offset += ps->totalGlyphPrivateSize / sizeof (DevUnion);
-	}
+    for (i = 0; i < screenInfo.numScreens; i++) {
+	pScreen = screenInfo.screens[i];
+	dixFreePrivates(*GetGlyphPrivatesForScreen(glyph, pScreen));
     }
-}
 
-static void
-SetGlyphPrivatePointers (GlyphPtr glyph)
-{
-    PictureScreenPtr ps;
-    int		     i;
-    char	     *ptr;
-    DevUnion         *ppriv;
-    unsigned         *sizes;
-    unsigned         size;
-    int		     len;
-
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ps = GetPictureScreenIfSet (screenInfo.screens[i]);
-	if (ps && ps->totalGlyphPrivateSize)
-	{
-	    ppriv = glyph->devPrivates + ps->glyphPrivateOffset;
-	    sizes = ps->glyphPrivateSizes;
-	    ptr = (char *) (ppriv + ps->glyphPrivateLen);
-	    for (len = ps->glyphPrivateLen; --len >= 0; ppriv++, sizes++)
-	    {
-		if ((size = *sizes) != 0)
-		{
-		    ppriv->ptr = (pointer) ptr;
-		    ptr += size;
-		}
-		else
-		    ppriv->ptr = (pointer) 0;
-	    }
-	}
-    }
-}
-
-static Bool
-ReallocGlobalGlyphPrivate (GlyphPtr glyph)
-{
-    PictureScreenPtr ps;
-    DevUnion         *devPrivates;
-    char	     *ptr;
-    int		     i;
-
-    devPrivates = xalloc (globalTotalGlyphPrivateSize);
-    if (!devPrivates)
-	return FALSE;
-
-    ptr = (char *) devPrivates;
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ps = GetPictureScreenIfSet (screenInfo.screens[i]);
-	if (ps && ps->totalGlyphPrivateSize)
-	{
-	    if (ps->glyphPrivateOffset != -1)
-	    {
-		memcpy (ptr, glyph->devPrivates + ps->glyphPrivateOffset,
-			ps->totalGlyphPrivateSize);
-	    }
-	    else if (ps->totalGlyphPrivateSize)
-	    {
-		memset (ptr, 0, ps->totalGlyphPrivateSize);
-	    }
-	    
-	    ptr += ps->totalGlyphPrivateSize;
-	}
-    }
-
-    if (glyph->devPrivates)
-	xfree (glyph->devPrivates);
-    
-    glyph->devPrivates = devPrivates;
-
-    return TRUE;
-}
-
-Bool
-GlyphInit (ScreenPtr pScreen)
-{
-    PictureScreenPtr ps = GetPictureScreen (pScreen);
-    
-    ps->totalGlyphPrivateSize = 0;
-    ps->glyphPrivateSizes = 0;
-    ps->glyphPrivateLen = 0;
-    ps->glyphPrivateOffset = -1;
-    
-    return TRUE;
-}
-
-Bool
-GlyphFinishInit (ScreenPtr pScreen)
-{
-    PictureScreenPtr ps = GetPictureScreen (pScreen);
-
-    if (ps->totalGlyphPrivateSize)
-    {
-	GlyphPtr glyph;
-	int	 fdepth, i;
-	
-	globalTotalGlyphPrivateSize += ps->totalGlyphPrivateSize;
-	
-	for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)
-	{
-	    if (!globalGlyphs[fdepth].hashSet)
-		continue;
-		
-	    for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)
-	    {
-		glyph = globalGlyphs[fdepth].table[i].glyph;
-		if (glyph && glyph != DeletedGlyph)
-		{
-		    if (!ReallocGlobalGlyphPrivate (glyph))
-			return FALSE;
-		}
-	    }
-	}
-
-	SetGlyphScreenPrivateOffsets ();
-
-	for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)
-	{
-	    if (!globalGlyphs[fdepth].hashSet)
-		continue;
-		
-	    for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)
-	    {
-		glyph = globalGlyphs[fdepth].table[i].glyph;
-		if (glyph && glyph != DeletedGlyph)
-		{
-		    SetGlyphPrivatePointers (glyph);
-			
-		    if (!(*ps->RealizeGlyph) (pScreen, glyph))
-			return FALSE;
-		}
-	    }
-	}
-    }
-    else
-	ps->glyphPrivateOffset = 0;
-    
-    return TRUE;
+    dixFreePrivates(glyph->devPrivates);
 }
 
 void
@@ -304,8 +102,6 @@ GlyphUninit (ScreenPtr pScreen)
     GlyphPtr	     glyph;
     int		     fdepth, i;
 
-    globalTotalGlyphPrivateSize -= ps->totalGlyphPrivateSize;
-
     for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)
     {
 	if (!globalGlyphs[fdepth].hashSet)
@@ -317,43 +113,20 @@ GlyphUninit (ScreenPtr pScreen)
 	    if (glyph && glyph != DeletedGlyph)
 	    {
 		(*ps->UnrealizeGlyph) (pScreen, glyph);
-		
-		if (globalTotalGlyphPrivateSize)
-		{
-		    if (!ReallocGlobalGlyphPrivate (glyph))
-			return;
-		}
-		else
-		{
-		    if (glyph->devPrivates)
-			xfree (glyph->devPrivates);
-		    glyph->devPrivates = NULL;
-		}
+		FreeGlyphPrivates(glyph);
+		glyph->devPrivates = NULL;
 	    }
 	}
     }
 
-    if (globalTotalGlyphPrivateSize)
-	SetGlyphScreenPrivateOffsets ();
-
     for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)
     {
 	if (!globalGlyphs[fdepth].hashSet)
 	    continue;
 	
 	for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)
-	{
 	    glyph = globalGlyphs[fdepth].table[i].glyph;    
-	    if (glyph && glyph != DeletedGlyph)
-	    {
-		if (globalTotalGlyphPrivateSize)
-		    SetGlyphPrivatePointers (glyph);
-	    }
-	}
     }
-
-    if (ps->glyphPrivateSizes)
-	xfree (ps->glyphPrivateSizes);
 }
 
 GlyphHashSetPtr
@@ -367,50 +140,6 @@ FindGlyphHashSet (CARD32 filled)
     return 0;
 }
 
-static int _GlyphSetPrivateAllocateIndex = 0;
-
-int
-AllocateGlyphSetPrivateIndex (void)
-{
-    return _GlyphSetPrivateAllocateIndex++;
-}
-
-void
-ResetGlyphSetPrivateIndex (void)
-{
-    _GlyphSetPrivateAllocateIndex = 0;
-}
-
-Bool
-_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, pointer ptr)
-{
-    pointer *new;
-
-    if (n > glyphSet->maxPrivate) {
-	if (glyphSet->devPrivates &&
-	    glyphSet->devPrivates != (pointer)(&glyphSet[1])) {
-	    new = (pointer *) xrealloc (glyphSet->devPrivates,
-					(n + 1) * sizeof (pointer));
-	    if (!new)
-		return FALSE;
-	} else {
-	    new = (pointer *) xalloc ((n + 1) * sizeof (pointer));
-	    if (!new)
-		return FALSE;
-	    if (glyphSet->devPrivates)
-		memcpy (new,
-			glyphSet->devPrivates,
-			(glyphSet->maxPrivate + 1) * sizeof (pointer));
-	}
-	glyphSet->devPrivates = new;
-	/* Zero out new, uninitialize privates */
-	while (++glyphSet->maxPrivate < n)
-	    glyphSet->devPrivates[glyphSet->maxPrivate] = (pointer)0;
-    }
-    glyphSet->devPrivates[n] = ptr;
-    return TRUE;
-}
-
 GlyphRefPtr
 FindGlyphRef (GlyphHashPtr hash, CARD32 signature, Bool match, GlyphPtr compare)
 {
@@ -539,8 +268,7 @@ FreeGlyph (GlyphPtr glyph, int format)
 		(*ps->UnrealizeGlyph) (screenInfo.screens[i], glyph);
 	}
 	
-	if (glyph->devPrivates)
-	    xfree (glyph->devPrivates);
+	FreeGlyphPrivates(glyph);
 	xfree (glyph);
     }
 }
@@ -566,8 +294,7 @@ AddGlyph (GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id)
 	    if (ps)
 		(*ps->UnrealizeGlyph) (screenInfo.screens[i], glyph);
 	}
-	if (glyph->devPrivates)
-	    xfree (glyph->devPrivates);
+	FreeGlyphPrivates(glyph);
 	xfree (glyph);
 	glyph = gr->glyph;
     }
@@ -634,16 +361,7 @@ AllocateGlyph (xGlyphInfo *gi, int fdepth)
     glyph->refcnt = 0;
     glyph->size = size + sizeof (xGlyphInfo);
     glyph->info = *gi;
-
-    if (globalTotalGlyphPrivateSize)
-    {
-	glyph->devPrivates = xalloc (globalTotalGlyphPrivateSize);
-	if (!glyph->devPrivates)
-	    return 0;
-
-	SetGlyphPrivatePointers (glyph);
-    } else
-	glyph->devPrivates = NULL;
+    glyph->devPrivates = NULL;
 
     for (i = 0; i < screenInfo.numScreens; i++)
     {
@@ -659,8 +377,7 @@ AllocateGlyph (xGlyphInfo *gi, int fdepth)
 			(*ps->UnrealizeGlyph) (screenInfo.screens[i], glyph);
 		}
 		
-		if (glyph->devPrivates)
-		    xfree (glyph->devPrivates);
+		FreeGlyphPrivates(glyph);
 		xfree (glyph);
 		return 0;
 	    }
@@ -744,15 +461,11 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
 	    return FALSE;
     }
 
-    size = (sizeof (GlyphSetRec) +
-	    (sizeof (pointer) * _GlyphSetPrivateAllocateIndex));
+    size = sizeof (GlyphSetRec);
     glyphSet = xalloc (size);
     if (!glyphSet)
 	return FALSE;
     bzero((char *)glyphSet, size);
-    glyphSet->maxPrivate = _GlyphSetPrivateAllocateIndex - 1;
-    if (_GlyphSetPrivateAllocateIndex)
-	glyphSet->devPrivates = (pointer)(&glyphSet[1]);
 
     if (!AllocateGlyphHash (&glyphSet->hash, &glyphHashSets[0]))
     {
@@ -792,11 +505,7 @@ FreeGlyphSet (pointer	value,
 	else
 	    ResizeGlyphHash (&globalGlyphs[glyphSet->fdepth], 0, TRUE);
 	xfree (table);
-
-	if (glyphSet->devPrivates &&
-	    glyphSet->devPrivates != (pointer)(&glyphSet[1]))
-	    xfree(glyphSet->devPrivates);
-
+	dixFreePrivates(glyphSet->devPrivates);
 	xfree (glyphSet);
     }
     return Success;
diff --git a/render/glyphstr.h b/render/glyphstr.h
index 22150deee..e89f34e59 100644
--- a/render/glyphstr.h
+++ b/render/glyphstr.h
@@ -30,6 +30,7 @@
 #include "screenint.h"
 #include "regionstr.h"
 #include "miscstruct.h"
+#include "privates.h"
 
 #define GlyphFormat1	0
 #define GlyphFormat4	1
@@ -40,7 +41,7 @@
 
 typedef struct _Glyph {
     CARD32	refcnt;
-    DevUnion	*devPrivates;
+    PrivateRec	*devPrivates;
     CARD32	size;	/* info + bitmap */
     xGlyphInfo	info;
     /* bits follow */
@@ -71,18 +72,14 @@ typedef struct _GlyphSet {
     int		    fdepth;
     GlyphHashRec    hash;
     int             maxPrivate;
-    pointer         *devPrivates;
+    PrivateRec      *devPrivates;
 } GlyphSetRec, *GlyphSetPtr;
 
-#define GlyphSetGetPrivate(pGlyphSet,n)					\
-	((n) > (pGlyphSet)->maxPrivate ?				\
-	 (pointer) 0 :							\
-	 (pGlyphSet)->devPrivates[n])
+#define GlyphSetGetPrivate(pGlyphSet,k)					\
+    dixLookupPrivate(&(pGlyphSet)->devPrivates, k)
 
-#define GlyphSetSetPrivate(pGlyphSet,n,ptr)				\
-	((n) > (pGlyphSet)->maxPrivate ?				\
-	 _GlyphSetSetNewPrivate(pGlyphSet, n, ptr) :			\
-	 ((((pGlyphSet)->devPrivates[n] = (ptr)) != 0) || TRUE))
+#define GlyphSetSetPrivate(pGlyphSet,k,ptr)				\
+    dixSetPrivate(&(pGlyphSet)->devPrivates, k, ptr)
 
 typedef struct _GlyphList {
     INT16	    xOff;
@@ -94,32 +91,6 @@ typedef struct _GlyphList {
 GlyphHashSetPtr
 FindGlyphHashSet (CARD32 filled);
 
-int
-AllocateGlyphSetPrivateIndex (void);
-
-void
-ResetGlyphSetPrivateIndex (void);
-
-Bool
-_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, pointer ptr);
-
-void
-ResetGlyphPrivates (void);
-
-int
-AllocateGlyphPrivateIndex (void);
-
-Bool
-AllocateGlyphPrivate (ScreenPtr pScreen,
-		      int	index2,
-		      unsigned	amount);
-
-Bool
-GlyphInit (ScreenPtr pScreen);
-
-Bool
-GlyphFinishInit (ScreenPtr pScreen);
-
 void
 GlyphUninit (ScreenPtr pScreen);
 
diff --git a/render/picture.c b/render/picture.c
index ede865f28..bc2c3b526 100644
--- a/render/picture.c
+++ b/render/picture.c
@@ -41,65 +41,14 @@
 #include "servermd.h"
 #include "picturestr.h"
 
-_X_EXPORT int	PictureScreenPrivateIndex = -1;
-int		PictureWindowPrivateIndex;
+_X_EXPORT DevPrivateKey PictureScreenPrivateKey = &PictureScreenPrivateKey;
+DevPrivateKey	PictureWindowPrivateKey = &PictureWindowPrivateKey;
 static int	PictureGeneration;
 RESTYPE		PictureType;
 RESTYPE		PictFormatType;
 RESTYPE		GlyphSetType;
 int		PictureCmapPolicy = PictureCmapPolicyDefault;
 
-/* Picture Private machinery */
-
-static int picturePrivateCount;
-
-void
-ResetPicturePrivateIndex (void)
-{
-    picturePrivateCount = 0;
-}
-
-int
-AllocatePicturePrivateIndex (void)
-{
-    return picturePrivateCount++;
-}
-
-Bool
-AllocatePicturePrivate (ScreenPtr pScreen, int index2, unsigned int amount)
-{
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
-    unsigned int	oldamount;
-
-    /* Round up sizes for proper alignment */
-    amount = ((amount + (sizeof(long) - 1)) / sizeof(long)) * sizeof(long);
-
-    if (index2 >= ps->PicturePrivateLen)
-    {
-	unsigned int *nsizes;
-
-	nsizes = (unsigned int *)xrealloc(ps->PicturePrivateSizes,
-					  (index2 + 1) * sizeof(unsigned int));
-	if (!nsizes)
-	    return FALSE;
-	while (ps->PicturePrivateLen <= index2)
-	{
-	    nsizes[ps->PicturePrivateLen++] = 0;
-	    ps->totalPictureSize += sizeof(DevUnion);
-	}
-	ps->PicturePrivateSizes = nsizes;
-    }
-    oldamount = ps->PicturePrivateSizes[index2];
-    if (amount > oldamount)
-    {
-	ps->PicturePrivateSizes[index2] = amount;
-	ps->totalPictureSize += (amount - oldamount);
-    }
-
-    return TRUE;
-}
-
-
 Bool
 PictureDestroyWindow (WindowPtr pWindow)
 {
@@ -137,8 +86,6 @@ PictureCloseScreen (int index, ScreenPtr pScreen)
 	    (*ps->CloseIndexed) (pScreen, &ps->formats[n]);
     GlyphUninit (pScreen);
     SetPictureScreen(pScreen, 0);
-    if (ps->PicturePrivateSizes)
-	xfree (ps->PicturePrivateSizes);
     xfree (ps->formats);
     xfree (ps);
     return ret;
@@ -497,8 +444,6 @@ PictureFinishInit (void)
 
     for (s = 0; s < screenInfo.numScreens; s++)
     {
-	if (!GlyphFinishInit (screenInfo.screens[s]))
-	    return FALSE;
 	if (!PictureInitIndexedFormats (screenInfo.screens[s]))
 	    return FALSE;
 	(void) AnimCurInit (screenInfo.screens[s]);
@@ -637,10 +582,6 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
 	GlyphSetType = CreateNewResourceType (FreeGlyphSet);
 	if (!GlyphSetType)
 	    return FALSE;
-	PictureScreenPrivateIndex = AllocateScreenPrivateIndex();
-	if (PictureScreenPrivateIndex < 0)
-	    return FALSE;
-	PictureWindowPrivateIndex = AllocateWindowPrivateIndex();
 	PictureGeneration = serverGeneration;
 #ifdef XResExtension
 	RegisterResourceName (PictureType, "PICTURE");
@@ -648,9 +589,6 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
 	RegisterResourceName (GlyphSetType, "GLYPHSET");
 #endif
     }
-    if (!AllocateWindowPrivate (pScreen, PictureWindowPrivateIndex, 0))
-	return FALSE;
-    
     if (!formats)
     {
 	formats = PictureCreateDefaultFormats (pScreen, &nformats);
@@ -697,18 +635,7 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
 	return FALSE;
     }
     SetPictureScreen(pScreen, ps);
-    if (!GlyphInit (pScreen))
-    {
-	SetPictureScreen(pScreen, 0);
-	xfree (formats);
-	xfree (ps);
-	return FALSE;
-    }
 
-    ps->totalPictureSize = sizeof (PictureRec);
-    ps->PicturePrivateSizes = 0;
-    ps->PicturePrivateLen = 0;
-    
     ps->formats = formats;
     ps->fallback = formats;
     ps->nformats = nformats;
@@ -774,37 +701,6 @@ SetPictureToDefaults (PicturePtr    pPicture)
 }
 
 PicturePtr
-AllocatePicture (ScreenPtr  pScreen)
-{
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
-    PicturePtr		pPicture;
-    char		*ptr;
-    DevUnion		*ppriv;
-    unsigned int    	*sizes;
-    unsigned int    	size;
-    int			i;
-
-    pPicture = (PicturePtr) xalloc (ps->totalPictureSize);
-    if (!pPicture)
-	return 0;
-    ppriv = (DevUnion *)(pPicture + 1);
-    pPicture->devPrivates = ppriv;
-    sizes = ps->PicturePrivateSizes;
-    ptr = (char *)(ppriv + ps->PicturePrivateLen);
-    for (i = ps->PicturePrivateLen; --i >= 0; ppriv++, sizes++)
-    {
-	if ( (size = *sizes) )
-	{
-	    ppriv->ptr = (pointer)ptr;
-	    ptr += size;
-	}
-	else
-	    ppriv->ptr = (pointer)NULL;
-    }
-    return pPicture;
-}
-
-PicturePtr
 CreatePicture (Picture		pid,
 	       DrawablePtr	pDrawable,
 	       PictFormatPtr	pFormat,
@@ -816,7 +712,7 @@ CreatePicture (Picture		pid,
     PicturePtr		pPicture;
     PictureScreenPtr	ps = GetPictureScreen(pDrawable->pScreen);
 
-    pPicture = AllocatePicture (pDrawable->pScreen);
+    pPicture = (PicturePtr)xalloc(sizeof(PictureRec));
     if (!pPicture)
     {
 	*error = BadAlloc;
@@ -827,6 +723,7 @@ CreatePicture (Picture		pid,
     pPicture->pDrawable = pDrawable;
     pPicture->pFormat = pFormat;
     pPicture->format = pFormat->format | (pDrawable->bitsPerPixel << 24);
+    pPicture->devPrivates = NULL;
     if (pDrawable->type == DRAWABLE_PIXMAP)
     {
 	++((PixmapPtr)pDrawable)->refcnt;
@@ -1607,7 +1504,8 @@ FreePicture (pointer	value,
                 WindowPtr	pWindow = (WindowPtr) pPicture->pDrawable;
                 PicturePtr	*pPrev;
 
-                for (pPrev = (PicturePtr *) &((pWindow)->devPrivates[PictureWindowPrivateIndex].ptr);
+                for (pPrev = (PicturePtr *)dixLookupPrivateAddr
+			 (&pWindow->devPrivates, PictureWindowPrivateKey);
                      *pPrev;
                      pPrev = &(*pPrev)->pNext)
                 {
@@ -1623,6 +1521,7 @@ FreePicture (pointer	value,
                 (*pScreen->DestroyPixmap) ((PixmapPtr)pPicture->pDrawable);
             }
         }
+	dixFreePrivates(pPicture->devPrivates);
 	xfree (pPicture);
     }
     return Success;
diff --git a/render/picturestr.h b/render/picturestr.h
index 005c58808..aafe4e80a 100644
--- a/render/picturestr.h
+++ b/render/picturestr.h
@@ -27,6 +27,7 @@
 #include "glyphstr.h"
 #include "scrnintstr.h"
 #include "resource.h"
+#include "privates.h"
 
 typedef struct _DirectFormat {
     CARD16	    red, redMask;
@@ -173,7 +174,7 @@ typedef struct _Picture {
 
     RegionPtr	    pCompositeClip;
 
-    DevUnion	    *devPrivates;
+    PrivateRec	    *devPrivates;
 
     PictTransform   *transform;
 
@@ -328,10 +329,6 @@ typedef void	(*UnrealizeGlyphProcPtr)    (ScreenPtr	    pScreen,
 					     GlyphPtr	    glyph);
 
 typedef struct _PictureScreen {
-    int				totalPictureSize;
-    unsigned int		*PicturePrivateSizes;
-    int				PicturePrivateLen;
-
     PictFormatPtr		formats;
     PictFormatPtr		fallback;
     int				nformats;
@@ -389,30 +386,25 @@ typedef struct _PictureScreen {
 
     AddTrapsProcPtr		AddTraps;
 
-    int			  	totalGlyphPrivateSize;
-    unsigned int	  	*glyphPrivateSizes;
-    int			  	glyphPrivateLen;
-    int			  	glyphPrivateOffset;
-
     RealizeGlyphProcPtr   	RealizeGlyph;
     UnrealizeGlyphProcPtr 	UnrealizeGlyph;
 
 } PictureScreenRec, *PictureScreenPtr;
 
-extern int		PictureScreenPrivateIndex;
-extern int		PictureWindowPrivateIndex;
+extern DevPrivateKey	PictureScreenPrivateKey;
+extern DevPrivateKey	PictureWindowPrivateKey;
 extern RESTYPE		PictureType;
 extern RESTYPE		PictFormatType;
 extern RESTYPE		GlyphSetType;
 
-#define GetPictureScreen(s) ((PictureScreenPtr) ((s)->devPrivates[PictureScreenPrivateIndex].ptr))
-#define GetPictureScreenIfSet(s) ((PictureScreenPrivateIndex != -1) ? GetPictureScreen(s) : NULL)
-#define SetPictureScreen(s,p) ((s)->devPrivates[PictureScreenPrivateIndex].ptr = (pointer) (p))
-#define GetPictureWindow(w) ((PicturePtr) ((w)->devPrivates[PictureWindowPrivateIndex].ptr))
-#define SetPictureWindow(w,p) ((w)->devPrivates[PictureWindowPrivateIndex].ptr = (pointer) (p))
+#define GetPictureScreen(s) ((PictureScreenPtr)dixLookupPrivate(&(s)->devPrivates, PictureScreenPrivateKey))
+#define GetPictureScreenIfSet(s) GetPictureScreen(s)
+#define SetPictureScreen(s,p) dixSetPrivate(&(s)->devPrivates, PictureScreenPrivateKey, p)
+#define GetPictureWindow(w) ((PicturePtr)dixLookupPrivate(&(w)->devPrivates, PictureWindowPrivateKey))
+#define SetPictureWindow(w,p) dixSetPrivate(&(w)->devPrivates, PictureWindowPrivateKey, p)
 
-#define GetGlyphPrivatesForScreen(glyph, s)				\
-    ((glyph)->devPrivates + (GetPictureScreen (s))->glyphPrivateOffset)
+#define GetGlyphPrivatesForScreen(glyph, s) \
+    ((PrivateRec **)dixLookupPrivateAddr(&(glyph)->devPrivates, s))
 
 #define VERIFY_PICTURE(pPicture, pid, client, mode, err) {\
     pPicture = SecurityLookupIDByType(client, pid, PictureType, mode);\
@@ -430,15 +422,6 @@ extern RESTYPE		GlyphSetType;
     } \
 } \
 
-void
-ResetPicturePrivateIndex (void);
-
-int
-AllocatePicturePrivateIndex (void);
-
-Bool
-AllocatePicturePrivate (ScreenPtr pScreen, int index2, unsigned int amount);
-
 Bool
 PictureDestroyWindow (WindowPtr pWindow);
 
@@ -501,9 +484,6 @@ PictureFinishInit (void);
 void
 SetPictureToDefaults (PicturePtr pPicture);
 
-PicturePtr
-AllocatePicture (ScreenPtr  pScreen);
-
 #if 0
 Bool
 miPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats);
diff --git a/render/render.c b/render/render.c
index e57ffb126..7b2745758 100644
--- a/render/render.c
+++ b/render/render.c
@@ -216,14 +216,14 @@ RenderResetProc (ExtensionEntry *extEntry);
 static CARD8	RenderReqCode;
 #endif
 int	RenderErrBase;
-int	RenderClientPrivateIndex;
+DevPrivateKey RenderClientPrivateKey;
 
 typedef struct _RenderClient {
     int	    major_version;
     int	    minor_version;
 } RenderClientRec, *RenderClientPtr;
 
-#define GetRenderClient(pClient)    ((RenderClientPtr) (pClient)->devPrivates[RenderClientPrivateIndex].ptr)
+#define GetRenderClient(pClient) ((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates, RenderClientPrivateKey))
 
 static void
 RenderClientCallback (CallbackListPtr	*list,
@@ -247,9 +247,7 @@ RenderExtensionInit (void)
 	return;
     if (!PictureFinishInit ())
 	return;
-    RenderClientPrivateIndex = AllocateClientPrivateIndex ();
-    if (!AllocateClientPrivate (RenderClientPrivateIndex, 
-				sizeof (RenderClientRec)))
+    if (!dixRequestPrivate(RenderClientPrivateKey, sizeof(RenderClientRec)))
 	return;
     if (!AddCallback (&ClientStateCallback, RenderClientCallback, 0))
 	return;
@@ -268,8 +266,6 @@ RenderExtensionInit (void)
 static void
 RenderResetProc (ExtensionEntry *extEntry)
 {
-    ResetPicturePrivateIndex();
-    ResetGlyphSetPrivateIndex();
 }
 
 static int