diff -r 000000000000 -r bde4ae8d615e os/textandloc/fontservices/fontstore/inc/openfontsprivate.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/textandloc/fontservices/fontstore/inc/openfontsprivate.h	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,430 @@
+/*
+* Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+#ifndef __OPENFONTS_PRIVATE_H__
+#define __OPENFONTS_PRIVATE_H__
+
+#include <hextree.h>
+#include <e32hashtab.h>
+
+class COpenFontShaperCacheEntry;
+
+/* MSB is set to indicate a glyph code rather than a unicode value
+   This is used for extracting the code value */
+#define GLYPH_CODE(code) (code & 0x7fffffff)
+
+/** COpenFontFile owned container for extra data. May be extended without affecting Binary Compatibility.
+
+ @internalComponent
+ */
+
+class TOpenFontFileData
+	{
+public:
+	CFontStore* iFontStore;			// pointer to the CFontStore instance that loaded the COpenFontFile
+	};
+
+/**
+ Note: this class must be self-contained, since instances are added to an RHexTree,
+ that is, it must be possible to destroy instances simply with RHeap::Free().
+ @internalComponent
+ */
+class COpenFontGlyph
+	{
+public:
+    static COpenFontGlyph* New(RHeap* aHeap, TInt aCode, TInt aGlyphIndex,
+                               const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+	inline static void Delete(RHeap* aHeap, COpenFontGlyph* aGlyph);
+	inline const TUint8* Bitmap() const;
+
+protected:
+	COpenFontGlyph(TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics)
+		: iCode(aCode), iGlyphIndex(aGlyphIndex), iMetrics(aMetrics), iBitmapOffset(0) {}
+	~COpenFontGlyph() {}
+	void SetBitmap(const TAny* aBitmap);
+
+public:
+	const TInt iCode;						// the Unicode value of the character
+	const TInt iGlyphIndex;					// the glyph index
+	const TOpenFontCharMetrics iMetrics;	// the metrics
+
+private:
+	// an offset from this COpenFontGlyph object to a pointer to the run-length-encoded bitmap, 
+	// calculated as (bitmapPointer)-(this)
+	TInt iBitmapOffset;
+	};
+
+/**
+ * Template for offset implementation of pointer array
+ @internalComponent
+ */
+template<class T>
+class ROffsetArray
+    {
+public:
+    ROffsetArray();
+    TInt Create(RHeap* aHeap, TInt aCount);
+    void Close(RHeap* aHeap);
+    TInt Count() const;
+    T* operator[](TInt aIndex) const;
+    void SetAt(TInt aIndex, T* aEntry);
+private:
+    TInt iOffset;
+    TInt iCount;
+    };
+
+
+/**
+ The per-font glyph cache. For now, just the members that used to be directly in
+ COpenFont. Now it is a private class it can be elaborated to do character-to-glyph-index
+ mapping when that is needed.
+
+ @internalComponent
+ */
+class COpenFontGlyphCache
+	{
+public:
+	COpenFontGlyphCache(RHeap* aHeap)
+	  : iGlyphTreeById(aHeap),
+		iGlyphTreeByUnicode(aHeap),
+		iGlyphCacheMemory(0),
+		iShaperCacheSentinel(NULL),
+		iShapingInfoCacheMemory(0),
+		iNumberOfShaperCacheEntries(0)
+		{}
+	TShapeHeader* SearchShaperCache(TInt aSessionHandle, TFontShapeFunctionParameters*& aParams);
+	TShapeHeader* Insert(TInt aSessionHandle, RHeap* aHeap, CShaper::TInput aInput, TShapeHeader* aShapeHeader, TInt& aAddedBytes);
+	TInt DeleteLeastRecentlyUsedEntry(RHeap* aHeap);
+	TBool ShaperCacheIsEmpty();
+	
+public:
+	RHexTree<COpenFontGlyph> iGlyphTreeById;				// a hex tree of glyphs indexed by glyph ID
+	RHexTree<COpenFontGlyph> iGlyphTreeByUnicode;			// a hex tree of glyphs indexed by Unicode code point
+	TInt iGlyphCacheMemory;									// memory used by the glyph tree in bytes
+	COpenFontShaperCacheEntry* iShaperCacheSentinel;
+	TInt iShapingInfoCacheMemory;
+	TInt iNumberOfShaperCacheEntries;	
+	};
+
+/**
+ @internalComponent
+ */
+class COpenFontSessionCacheEntry: public COpenFontGlyph
+	{
+public:
+	static COpenFontSessionCacheEntry* New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex,
+										   const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+	inline static void Delete(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry);
+	inline const COpenFont* Font()const;
+
+private:
+	inline COpenFontSessionCacheEntry(const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics);
+	~COpenFontSessionCacheEntry();
+
+private: 
+    TInt iFontOffset;          // offset of the font that contains this glyph, (not owned by this class!)    
+	};
+
+/**
+ A glyph cache for a particular session.
+ Because session caches are not shared they can shrink as well as grow.
+
+ @internalComponent
+ */
+class COpenFontSessionCache
+    {
+	friend class COpenFontSessionCacheList;
+public:
+    static COpenFontSessionCache* NewL(RHeap* aHeap, TInt aSessionHandle, TInt aEntries);
+    void Delete(RHeap* aHeap);
+    
+    TInt SessionHandle() { return iSessionHandle; }
+    const COpenFontGlyph* Glyph(const COpenFont* aFont, TInt aCode, TInt& aIndex) const;
+    void Insert(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry, TInt aIndex);
+    
+private:
+    COpenFontSessionCache(TInt aSessionHandle);
+    ~COpenFontSessionCache();
+private:
+    TInt iSessionHandle;
+    TInt64 iRandomSeed;
+    ROffsetArray<COpenFontSessionCacheEntry> iEntryArray;
+    };
+
+
+class TFontTableGlyphOutlineCacheMemMonitor
+    {
+public:
+    TFontTableGlyphOutlineCacheMemMonitor();
+    void Inc(TInt aBytes);
+    void Dec(TInt aBytes);
+    TInt GetMemUsage();
+private:
+    TInt iBytes;
+    };
+
+struct TCacheUserInfo {
+    TInt iSessionHandle;
+    TInt iRefCount;
+    TCacheUserInfo(TInt aSessionHandle, TInt aRefCount = 0): 
+            iSessionHandle(aSessionHandle), iRefCount(aRefCount) { } 
+};
+
+class CFontTableCache;
+
+class CFontTableCacheItem
+    {
+friend class CFontTableCache ;
+
+public:
+    CFontTableCacheItem(TUid &aFileUid, const TUint32 aTag, 
+            TInt aOffset, TInt aLength);
+    ~CFontTableCacheItem(); 
+
+    TInt DecRefCount(TInt aSessionHandle);
+    TInt IncRefCount(TInt aSessionHandle);
+
+    TBool HasOutstandingRefCount();
+    TInt FindUser(TInt aSessionHandle, TInt *id);
+    
+#ifdef _DEBUG
+    void SetUser(RPointerArray<TCacheUserInfo> users)
+        {
+        TInt len = users.Count();
+        for( TInt i = 0; i < len ; i++ )
+            {
+            iUsers.Append(users[i]);
+            }
+        }    
+#endif
+    
+private:
+    CFontTableCacheItem(const CFontTableCacheItem &); // disallow copy construction.
+    CFontTableCacheItem& operator =(const CFontTableCacheItem &); // disallow assignment.
+    
+    TUid iFileUid; 
+    TUint32 iTag; 
+ 
+
+    TInt iOffset;
+    TInt iLength; 
+    RPointerArray<TCacheUserInfo> iUsers;
+    }; 
+
+
+class CFontTableCache 
+    {
+public:
+    CFontTableCache(RHeap* aHeap, TFontTableGlyphOutlineCacheMemMonitor& aMon);
+    ~CFontTableCache();
+    TInt Append(TUid aFileUid, TUint32 aTag, 
+            TAny*& aContent, TInt aLength);
+    TInt Find(TUid aFileUid, TUint32 aTag, TAny*& aContent, TInt& aLength, TInt* id);
+    TInt IncRefCount(TUid FileUid, TUint32 aTag, TInt aSessionHandle);
+    TInt DecRefCount(TUid aFileUid, TUint32 aTag, TInt aSessionHandle);
+    TBool HasOutstandingRefCount();
+    TBool HasOutstandingRefCountWithUid(TUid aFileUid);  
+    void CleanupCacheOnFbsSessionTermination(TInt aSessionHandle);
+    void CleanupCacheOnOpenFontFileRemoval(COpenFontFile*);
+#ifdef _DEBUG    
+    void SetFontItem(RPointerArray<CFontTableCacheItem> cacheItems)
+        {
+        TInt len = cacheItems.Count();
+        for(TInt i = 0; i < len; i++)
+            {
+            iCacheItems.Append(cacheItems[i]);
+            }
+        }
+#endif   
+    
+private:
+    CFontTableCache(const CFontTableCache &); // no copy construction.
+    CFontTableCache& operator =(const CFontTableCache &); // no assignment.
+#ifdef _DEBUG
+    TInt GetCacheState(const char *func);
+#endif
+    
+    TFontTableGlyphOutlineCacheMemMonitor &iCacheMemMon;
+    RHeap *iHeap;
+    RPointerArray<CFontTableCacheItem> iCacheItems;
+    };
+
+
+class TUnhintedOutlineCache;
+
+class TUnhintedOutlineId 
+    {
+public:
+    TUnhintedOutlineId(TUid aFileUid, TInt aFaceIndex, TUint aId);
+    TUid iFileUid;
+    TInt iFaceIndex;
+    TUint iId;
+    };
+
+class COutlineCacheItem {
+friend class CUnhintedOutlineCache;
+friend class CHintedOutlineCache;
+    
+public:
+    COutlineCacheItem(TInt aOffset, TInt aLength);
+    ~COutlineCacheItem() ;
+
+    TInt DecRefCount(TInt aSessionHandle);
+    TInt IncRefCount(TInt aSessionHandle);
+#ifdef _DEBUG
+    void SetUser(RPointerArray<TCacheUserInfo> users)
+        {
+        TInt len = users.Count();
+        for( TInt i = 0; i < len ; i++ )
+            {
+            iUsers.Append(users[i]);
+            }
+        }    
+#endif
+ 
+private:
+    TInt FindUser(TInt aSessionHandle, TInt *id);
+        
+
+    TInt iOffset;
+    TInt iLength;
+    RPointerArray<TCacheUserInfo> iUsers;
+};    
+
+class CUnhintedOutlineCache {
+public:
+    CUnhintedOutlineCache(RHeap* aHeap, TFontTableGlyphOutlineCacheMemMonitor& aMon);
+    TInt Find(const TUnhintedOutlineId &aOutlineId, TAny*& aData, TInt& aLength);
+    TInt IncRefCount(const TUnhintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt DecRefCount(const TUnhintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt CacheUnhintedOutline(const TUnhintedOutlineId& aOutlineId, 
+            TAny * const aData, const TInt aLength, TAny*& aOutline, TInt &aLen);
+    TInt CleanupCacheOnOpenFontFileRemoval(COpenFontFile* aFontFile);
+    TInt CleanupCacheOnFbsSessionTermination(TInt aSessionHandle);
+#ifdef _DEBUG
+    TInt GetCacheState(const char *func);
+#endif
+    ~CUnhintedOutlineCache();
+    
+#ifdef _DEBUG
+    void SetUnHintedItem(TUnhintedOutlineId id, COutlineCacheItem* item)
+        {
+        iItemIdMap.Insert(id, item);
+        }
+#endif
+    
+private:
+    // disallow assignment and copy-construction
+    CUnhintedOutlineCache(const CUnhintedOutlineCache &); 
+    CUnhintedOutlineCache& operator =(const CUnhintedOutlineCache &);
+    
+    static TUint32 IdHash(const TUnhintedOutlineId& aOutlineId);
+    static TBool IdIdentity(const TUnhintedOutlineId& id1, const TUnhintedOutlineId& id2);
+    
+    TFontTableGlyphOutlineCacheMemMonitor& iCacheMemMon;
+    RHeap* iHeap; 
+    RHashMap<TUnhintedOutlineId, COutlineCacheItem*> iItemIdMap; // map the identity to an index in 'iCacheItems'.
+};
+
+class CHintedOutlineCache;
+
+class THintedOutlineId 
+    {
+public:
+    THintedOutlineId(COpenFont* aFont, TUint aId);
+    COpenFont *iFont;
+    TUint iId;
+    };
+
+
+class CHintedOutlineCache {
+public:
+    CHintedOutlineCache(RHeap* aHeap, TFontTableGlyphOutlineCacheMemMonitor& aMon);
+    TInt Find(const THintedOutlineId& aOutlineId, TAny*& aData, TInt& aLength);
+    TInt IncRefCount(const THintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt DecRefCount(const THintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt CacheHintedOutline(const THintedOutlineId& aOutlineId, 
+            TAny* aData, TInt aLength, TAny*& aOutline, TInt& aLen);
+    TInt CleanupCacheOnOpenFontRemoval(COpenFont* aFont);
+    TInt CleanupCacheOnFbsSessionTermination(TInt aSessionHandle);
+#ifdef _DEBUG
+    TInt GetCacheState(const char *func);
+    void SetHintedItem(THintedOutlineId id, COutlineCacheItem* item)
+        {
+        iItemIdMap.Insert(id, item);
+        }
+    RHashMap<THintedOutlineId, COutlineCacheItem*> GetHintedMap()
+    {
+    return iItemIdMap;
+    }
+#endif
+    
+private:
+    // disallow assignment and copy-construction
+    CHintedOutlineCache(const CHintedOutlineCache &); 
+    CHintedOutlineCache& operator =(const CHintedOutlineCache &);
+    static TUint32 IdHash(const THintedOutlineId& aOutlineId);
+    static TBool IdIdentity(const THintedOutlineId& id1, const THintedOutlineId& id2);
+        
+    TFontTableGlyphOutlineCacheMemMonitor& iCacheMemMon;
+    RHeap* iHeap; 
+    RHashMap<THintedOutlineId, COutlineCacheItem*> iItemIdMap; // map the identity to an index in 'iCacheItems'.
+    };
+
+
+// inline functions
+
+inline void COpenFontGlyph::Delete(RHeap* aHeap, COpenFontGlyph* aGlyph)
+	{
+	aHeap->Free(aGlyph);
+	}
+
+/**
+@return A pointer to the bitmap data stored with this glyph, or NULL
+if no bitmap has been stored with this glyph.
+ */
+inline const TUint8* COpenFontGlyph::Bitmap() const
+	{
+	if (iBitmapOffset)
+		{
+		return reinterpret_cast<const TUint8*>(PtrAdd(this, iBitmapOffset));
+		}
+	return NULL;
+	}
+
+inline COpenFontSessionCacheEntry::COpenFontSessionCacheEntry(const COpenFont* aFont, TInt aCode, TInt aGlyphIndex,const TOpenFontCharMetrics& aMetrics) :
+    COpenFontGlyph(aCode, aGlyphIndex, aMetrics)
+    {
+    iFontOffset = aFont ? reinterpret_cast<TInt>(aFont) - reinterpret_cast<TInt>(this) : 0;
+    }
+
+inline void COpenFontSessionCacheEntry::Delete(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry)
+	{
+	COpenFontGlyph::Delete(aHeap, aEntry);
+	}
+
+inline const COpenFont* COpenFontSessionCacheEntry::Font() const
+    {
+    if (iFontOffset)
+        {
+        return reinterpret_cast<const COpenFont*> (PtrAdd(this, iFontOffset));
+        }
+    return NULL;
+    }
+
+#endif	// __OPENFONTSPRIVATE_H__