FCL/sf/os/textandloc: comparison fontservices/fontstore/src/OPENFONT.CPP

equal deleted inserted replaced

-:662fa7de7023
+:6124ff6478cc
 glyphCache = (COpenFontGlyphCache*) iHeap->Alloc(sizeof(COpenFontGlyphCache));
 if (glyphCache == NULL) // no memory
 {
 return NULL;
 }
-new (glyphCache) COpenFontGlyphCache;
+new (glyphCache) COpenFontGlyphCache(iHeap);
 SetGlyphCache(glyphCache);
 }
 // If there is no sentinel present, i.e. new cache
 if (glyphCache->iShaperCacheSentinel == NULL)
 {
 	File()->GetFontStore()->CleanupCacheOnOpenFontRemoval(this);
 	COpenFontGlyphCache* glyphCache = GetGlyphCache();
 	if (glyphCache != NULL)
 		{
-		COpenFontGlyphTreeEntry* next = NULL;
+		glyphCache->iGlyphTreeById.ResetAndDestroy();
-		for (COpenFontGlyphTreeEntry* g = glyphCache->iGlyphList; g != NULL; g = next)
+		glyphCache->iGlyphTreeByUnicode.ResetAndDestroy();
-			{
-			next = g->iNext;
-			COpenFontGlyph::Delete(iHeap, g);
-			}
 		// Delete the shaper cache as well
 		if (glyphCache->iShaperCacheSentinel)
 			{
 			COpenFontShaperCacheEntry* previous  = NULL;
 {
 file->RemoveFontFromList(this);
 }
 	}
-COpenFontGlyph::~COpenFontGlyph()
-	{
-	}
-void COpenFontGlyph::Delete(RHeap* aHeap, COpenFontGlyph* aGlyph)
-	{
-	if (aGlyph != NULL)
-		{
-		aHeap->Free(aGlyph->Bitmap());
-		aHeap->Free(aGlyph);
-		}
-	}
 EXPORT_C void COpenFont::operator delete(TAny *aFont)
 	{
 	if(aFont != NULL)
 		{
 		COpenFont* f = (COpenFont*)aFont;
 glyphCache = (COpenFontGlyphCache*)iHeap->Alloc(sizeof(COpenFontGlyphCache));
 		if (glyphCache == NULL) // no memory
 			{
 			return EFalse;
 			}
-		new(glyphCache) COpenFontGlyphCache;
+		new(glyphCache) COpenFontGlyphCache(iHeap);
 		SetGlyphCache(glyphCache);
 		}
 	// Look in the Font Cache
-	TInt* nodeInsertPtr = NULL;
+	const COpenFontGlyph* g = FontCacheGlyph(aCode);
-	const COpenFontGlyph* g = FontCacheGlyph(aCode, nodeInsertPtr);
-	// If it is not found there look in the session cache.
-	COpenFontSessionCache* cache = NULL;
-	TInt index = 0;
-	if (g == NULL)
-		{
-		g = SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, EFalse);
-		}
 	// If it has already been rasterized return it.
 	if (g != NULL)
 		{
 		if (aGlyphData != NULL)
 		return EFalse;
 		}
 	TBool glyph_data_valid = ETrue;
 	const TOpenFontGlyphData* cur_glyph_data = temp_glyph_data ? temp_glyph_data : aGlyphData;
-	const COpenFontGlyph* new_glyph = NULL;
+	COpenFontGlyph* new_glyph = NULL;
 	// If the maximum per-font cache memory will not be exceeded, put the glyph into the font cache.
-	TInt bytes = sizeof(COpenFontGlyphTreeEntry) + cur_glyph_data->BytesNeeded();
+	TInt bytes = sizeof(COpenFontGlyph) + cur_glyph_data->BytesNeeded();
 	if(glyphCache != NULL && bytes + glyphCache->iGlyphCacheMemory <= KMaxGlyphCacheMemory)
 		{
-		COpenFontGlyphTreeEntry* new_entry = COpenFontGlyphTreeEntry::New(iHeap, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
+		new_glyph = COpenFontGlyph::New(iHeap, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
-		new_glyph=new_entry;
+		if (new_glyph != NULL)
-		if (new_entry != NULL)
 {
-// Add the glyph to a leaf node using the nodeInsertPtr that was returned by FontCacheGlyph()
+			if ((aCode & 0x80000000) != 0)
-// This is the first node if the glyph cache is empty. This updates the cache atomically.
+				{
-*nodeInsertPtr = PointerToThisOffset(new_entry);
+				error = glyphCache->iGlyphTreeById.SetAt(aCode & 0x7FFFFFFF, new_glyph);
+				}
-// If new_entry is not the first in the cache, set the previous
+			else
-// entry to link to this so that a linked-list of entries can be
+				{
-// maintained to simplify deletion.
+				error = glyphCache->iGlyphTreeByUnicode.SetAt(aCode, new_glyph);
-COpenFontGlyphTreeEntry* tree = static_cast<COpenFontGlyphTreeEntry*> (ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
+				}
-__ASSERT_DEBUG(tree != NULL, User::Invariant());
+			if (error == KErrNone)
-if (new_entry != tree)
+			    {
-{
+glyphCache->iGlyphCacheMemory += bytes;
-while (tree->iNext != NULL)
+			    }
-{
+			else
-tree = tree->iNext;
+			    {
-}
+iHeap->Free(new_glyph);
-tree->iNext = new_entry;
+new_glyph = NULL;
-}
+			    }
-else
+}
-{
+		}
-// First entry in tree, initialise iGlyphList
+	// Otherwise put the glyph into the per-session cache.
-glyphCache->iGlyphList = new_entry;
-}
-glyphCache->iGlyphCacheMemory += bytes;
-}//if (new_entry)
-		}
 	else
 		{
-		error = KErrGeneral;
+		// Look in the session cache. Do not expect to find the glyph here
-		}
+		// since the session cache has already been searched client-side.
+		// However, SessionCacheGlyph() is called so that the session cache is
-	// Otherwise put the glyph into the per-session cache.
+		// created if needed and an index is found where the new glyph will be
-	if (error != KErrNone)
+		// placed when added to the session cache.
-		{
+		COpenFontSessionCache* cache = NULL;
-		// If the session cache is not yet known find it or create one.
+		TInt index = 0;
-		if (cache == NULL)
+		(void)SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, ETrue);
-			{
-			SessionCacheGlyph(iHeap, aSessionHandle, aCode, cache, index, TRUE);
-			}
 		if (cache == NULL)
 			{
+			iHeap->Free(temp_glyph_data);
 			return EFalse;
 			}
 		COpenFontSessionCacheEntry* new_entry =
 			COpenFontSessionCacheEntry::New(iHeap, this, aCode, cur_glyph_data->GlyphIndex(), *cur_glyph_data->Metrics(), cur_glyph_data->Bitmap());
 aHinted, aOutline, aLength);
 }
 return ret;
 }
-/** Given the passed pointer aAny, return an offset from it to the "this" pointer
-of this COpenFont object.
-@param aAny A pointer to an object that exists on the shared heap, i.e. the same heap
-that this CCOpenFont object was created on.
-@return An offset relative to the "this" pointer for this object, this offset can
-be converted back to a pointer using ThisOffsetToPointer().
-@see ThisOffsetToPointer().
-@internalComponent
-*/
-TInt COpenFont::PointerToThisOffset(const TAny* aAny)
-	{
-	if (aAny != NULL)
-		{
-		return ((TInt)aAny - (TInt)this);
-		}
-	return 0;
-	}
-/** Given the passed passed offset aThisOffset, convert it to a pointer relative to
-the "this" pointer for this object.
-@param aThisOffset An offset that was generated using PointerToThisOffset().
-@return A pointer that has been created by adding (this+aThisOffset).
-@see PointerToThisOffset().
-@internalComponent
-*/
-TAny* COpenFont::ThisOffsetToPointer(const TInt aThisOffset)
-	{
-	if (aThisOffset)
-		{
-		return (TAny*)((TInt)this + aThisOffset);
-		}
-	return NULL;
-	}
 /**
 A constructor initialised with a TCharacterMetrics object.
 This is the old-style character metrics object. As for other T classes, there
 The cache is now created in COpenFont::Rasterize which can only be called within the context of FBSERV
 @param aCode The code for the glpyh to look for in the cache
 @return A pointer to the requested glyph if it was found in the glyph cache, NULL if it was not found.
 */
 const COpenFontGlyph* COpenFont::FontCacheGlyph(TInt aCode)
 	{
 	if (COpenFontGlyphCache* glyphCache = GetGlyphCache())
 		{
-		COpenFontGlyphTreeEntry* node = NULL;
+		if ((aCode & 0x80000000) != 0)
-		if (glyphCache->iGlyphTreeOffset)
+			{
-			{
+			return glyphCache->iGlyphTreeById.At(aCode & 0x7FFFFFFF);
-			node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
+			}
-			}
+		else
+			{
-		while (node != NULL)
+			return glyphCache->iGlyphTreeByUnicode.At(aCode);
-			{
+			}
-			TInt code = node->iCode;
-			if(code == aCode)
-				{
-				// Found the glyph
-				return node;
-				}
-			else if(code > aCode)
-				{
-				node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(node->iLeftOffset));
-				}
-			else
-				{
-				node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(node->iRightOffset));
-				}
-			}
-		}
-	// No glyph found
-	return NULL;
-	}
-/**
-Retrieve glyph data from the per-font glyph cache.
-If it is not found return NULL and place the address of the node pointer
-to receive a new glyph in aNodeInsertPtr.
-If the cache hasn't been created, then return NULL.
-Previous versions of this function created the cache, but as this function can potentially
-run in the context of threads other than FBSERV the alloc could panic if iHeap's chunk had to
-be resized - this is not allowed by the kernel.
-The cache is now created in COpenFont::Rasterize which can only be called within the context of FBSERV
-@param aCode The code for the glpyh to look for in the cache
-@param aNodeInsertPtr Returns a pointer to a final empty left or right leaf node
-in the glpyh tree where the searched for glyph can be inserted if necessary.
-@return A pointer to the requested glyph if it was found in the glyph cache, NULL if it was not found.
-*/
-const COpenFontGlyph* COpenFont::FontCacheGlyph(TInt aCode, TInt*& aNodeInsertPtr)
-	{
-	aNodeInsertPtr = NULL;
-	if (COpenFontGlyphCache* glyphCache = GetGlyphCache())
-		{
-COpenFontGlyphTreeEntry* node = NULL;
-if (glyphCache->iGlyphTreeOffset)
-{
-node = static_cast<COpenFontGlyphTreeEntry*> (ThisOffsetToPointer(glyphCache->iGlyphTreeOffset));
-}
-else
-{
-aNodeInsertPtr = &glyphCache->iGlyphTreeOffset;
-}
-while (node != NULL)
-			{
-			TInt code = node->iCode;
-			if(code == aCode)
-				{
-				// Found the glyph
-				return node;
-				}
-			else if(code > aCode)
-				{
-				aNodeInsertPtr = &node->iLeftOffset;
-				node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(node->iLeftOffset));
-				}
-			else
-				{
-				aNodeInsertPtr = &node->iRightOffset;
-				node = static_cast<COpenFontGlyphTreeEntry*>(ThisOffsetToPointer(node->iRightOffset));
-				}
-			}
 		}
 	// No glyph found
 	return NULL;
 	}
 const COpenFontGlyph* COpenFont::SessionCacheGlyph(RHeap* aHeap,
 	TInt aSessionHandle, TInt aCode, COpenFontSessionCache*& aCache,
 	TInt& aIndex, TBool aCreate) const
 	{
 	aIndex = 0;
-	COpenFontSessionCacheListItem* prev = NULL;
+	COpenFontSessionCacheList* cacheList = SessionCacheList();
+	aCache = cacheList->FindCache(aSessionHandle);
-	COpenFontSessionCacheList* cachelist = const_cast<COpenFont*>(this)->SessionCacheList();
+	if (aCache != NULL)
-	RSemaphore sem;
+		{
-	if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
+		return aCache->Glyph(this, aCode, aIndex);
-	    {
+		}
-	    RDebug::Print(_L("COpenFont::SessionCacheGlyphe() can't open SessionCacheSemaphore"));
-	    return NULL;
-	    }
-	sem.Wait();
-	COpenFontSessionCacheListItem* cacheListStart=cachelist->Start();
-	if(cacheListStart != NULL)
-		{
-		for (COpenFontSessionCacheListItem* p = cacheListStart; p; p = p->Next())
-			{
-			COpenFontSessionCache* cache=p->Cache();
-			if (cache->iSessionHandle == aSessionHandle)
-				{
-				aCache = cache;
-				sem.Signal();
-				sem.Close();
-				return aCache->Glyph(this,aCode,aIndex);
-				}
-			prev = p;
-			}
-		}
-	sem.Signal();
-	sem.Close();
 	if (aCreate)
 		{
 		COpenFontSessionCache* new_cache = NULL;
 		TRAPD(error, new_cache = COpenFontSessionCache::NewL(aHeap, aSessionHandle, KSessionCacheEntries));
 		if ((!error) && new_cache != NULL)
 			{
-			COpenFontSessionCacheListItem* new_item = (COpenFontSessionCacheListItem*)aHeap->Alloc(sizeof(COpenFontSessionCacheListItem));
+			if (cacheList->AddCache(new_cache) != KErrNone)
-			if (new_item == NULL)
 				{
 				new_cache->Delete(aHeap);
 				aHeap->Free(new_cache);
 				return NULL;
 				}
-			new(new_item) COpenFontSessionCacheListItem(new_cache);
-			if (prev != NULL)
-				{
-				prev->SetNext(new_item);
-				}
-			else
-				{
-				cachelist->SetStart(new_item);
-				}
 			aCache = new_cache;
 			aIndex = GLYPH_CODE(aCode) % KSessionCacheEntries;
 			}
 		}
 	return NULL;
 /**
 Create a glyph data object on the shared heap, given the code, metrics and the data bytes.
 The data is copied; ownership remains with the caller.
 */
-COpenFontGlyph* COpenFontGlyph::NewL(RHeap* aHeap, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
+COpenFontGlyph* COpenFontGlyph::New(RHeap* aHeap, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
 	{
-	COpenFontGlyph* glyph = (COpenFontGlyph*)aHeap->AllocL(sizeof(COpenFontGlyph));
+	COpenFontGlyph* glyph = (COpenFontGlyph*)aHeap->Alloc(sizeof(COpenFontGlyph) + aBitmap.Size());
-	new(glyph) COpenFontGlyph(aCode, aGlyphIndex, aMetrics);
+if (glyph == NULL)
-	if (!glyph->SetBitmap(aHeap, aBitmap))
+{
-		{
+return NULL;
-		aHeap->Free(glyph);
+}
-		User::Leave(KErrNoMemory);
+new(glyph) COpenFontGlyph(aCode, aGlyphIndex, aMetrics);
-		}
+	glyph->SetBitmap(glyph + 1);
+	Mem::Copy(glyph + 1, aBitmap.Ptr(), aBitmap.Size());
 	return glyph;
 	}
-COpenFontGlyphTreeEntry* COpenFontGlyphTreeEntry::New(RHeap* aHeap, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
+COpenFontSessionCacheEntry* COpenFontSessionCacheEntry::New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
 	{
-	COpenFontGlyphTreeEntry* entry = (COpenFontGlyphTreeEntry*)aHeap->Alloc(sizeof(COpenFontGlyphTreeEntry));
+	COpenFontSessionCacheEntry* entry = (COpenFontSessionCacheEntry*)aHeap->Alloc(sizeof(COpenFontSessionCacheEntry) + aBitmap.Size());
 	if (entry == NULL)
+		{
 		return NULL;
-	new(entry) COpenFontGlyphTreeEntry(aCode, aGlyphIndex, aMetrics);
+		}
-	if (!entry->SetBitmap(aHeap, aBitmap))
+	new(entry) COpenFontSessionCacheEntry(aFont, aCode, aGlyphIndex, aMetrics);
-		{
+	entry->SetBitmap(entry + 1);
-		aHeap->Free(entry);
+	Mem::Copy(entry + 1, aBitmap.Ptr(), aBitmap.Size());
-		entry = NULL;
-		}
 	return entry;
 	}
-COpenFontSessionCacheEntry* COpenFontSessionCacheEntry::New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap)
+void COpenFontGlyph::SetBitmap(const TAny* aBitmap)
 	{
-	COpenFontSessionCacheEntry* entry = (COpenFontSessionCacheEntry*)aHeap->Alloc(sizeof(COpenFontSessionCacheEntry));
+	iBitmapOffset = reinterpret_cast<TInt>(aBitmap) - reinterpret_cast<TInt>(this);
-	if (entry == NULL)
-		return NULL;
-	new(entry) COpenFontSessionCacheEntry(aFont, aCode, aGlyphIndex, aMetrics);
-	if (!entry->SetBitmap(aHeap, aBitmap))
-		{
-		aHeap->Free(entry);
-		entry = NULL;
-		}
-	return entry;
-	}
-/**
-@return A pointer to the run-length-encoded bitmap stored with this glyph, or NULL
-if no bitmap has been stored with this glyph.
-*/
-TUint8* COpenFontGlyph::Bitmap() const
-	{
-	if (iBitmapOffset)
-		{
-		return reinterpret_cast<TUint8*>(reinterpret_cast<TInt>(this) + iBitmapOffset);
-		}
-	return NULL;
-	}
-TBool COpenFontGlyph::SetBitmap(RHeap* aHeap, const TDesC8& aBitmap)
-	{
-	TUint8* bitmap = (TUint8*)aHeap->Alloc(aBitmap.Length());
-	if (bitmap == NULL)
-		return EFalse;
-	Mem::Copy(bitmap, aBitmap.Ptr(), aBitmap.Length());
-	aHeap->Free(Bitmap());
-	iBitmapOffset = reinterpret_cast<TInt>(bitmap) - reinterpret_cast<TInt>(this);
-	return ETrue;
 	}
 COpenFontSessionCache* COpenFontSessionCache::NewL(RHeap* aHeap, TInt aSessionHandle, TInt aEntries)
 	{
 COpenFontSessionCache* c = (COpenFontSessionCache*)aHeap->AllocL(sizeof(COpenFontSessionCache));
 	}
 void COpenFontSessionCache::Delete(RHeap* aHeap)
 {
-TInt entries = iEntryArray.Count();
+TInt numEntries = iEntryArray.Count();
-for (TInt i = 0; i < entries; ++i)
+for (TInt i = 0; i < numEntries; ++i)
 {
-COpenFontSessionCacheEntry* e = iEntryArray[i];
+COpenFontSessionCacheEntry* entry = iEntryArray[i];
-if (e != NULL)
+if (entry != NULL)
 {
-COpenFont* font=const_cast<COpenFont*>(e->Font());
+COpenFont* font=const_cast<COpenFont*>(entry->Font());
 if (font != NULL)
 font->DecrementCachedRefCount(iSessionHandle,NULL,ETrue);
-aHeap->Free(e->Bitmap());
+COpenFontSessionCacheEntry::Delete(aHeap, entry);
-aHeap->Free(e);
 }
 }
 iEntryArray.Close(aHeap);
 }
 const COpenFontGlyph* COpenFontSessionCache::Glyph(const COpenFont* aFont, TInt aCode, TInt& aIndex)
 	{
 aIndex = -1;
 TInt oldest = KMaxTInt;
 TInt oldest_index = 0;
-TInt entries = iEntryArray.Count();
+TInt numEntries = iEntryArray.Count();
-TInt index = GLYPH_CODE(aCode) % entries;   // simple hash function to shorten searches
+TInt index = GLYPH_CODE(aCode) % numEntries;   // simple hash function to shorten searches
-for (TInt i = 0; i < entries; ++i, ++index)
+for (TInt i = 0; i < numEntries; ++i, ++index)
 {
-if (index >= entries)
+if (index >= numEntries)
 index = 0;
-COpenFontSessionCacheEntry* e = iEntryArray[index];
+COpenFontSessionCacheEntry* entry = iEntryArray[index];
-if (e == NULL)
+if (entry == NULL)
 {
 if (aIndex == -1)
 aIndex = index;
 }
 else
 {
-if (e->Font() == aFont && e->iCode == aCode)
+if (entry->Font() == aFont && entry->iCode == aCode)
 {
-e->iLastAccess = iLastAccess++;
+entry->iLastAccess = iLastAccess++;
-return e;
+return entry;
 }
-if (e->iLastAccess < oldest)
+if (entry->iLastAccess < oldest)
 {
-oldest = e->iLastAccess;
+oldest = entry->iLastAccess;
 oldest_index = index;
 }
 }
 }
 if (aIndex == -1)
 void COpenFontSessionCache::Insert(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry, TInt aIndex)
 	{
 if (aIndex < 0 || aIndex >= iEntryArray.Count())
+{
 Panic(EFntSessionCacheIndexOutOfRange);
-COpenFontGlyph::Delete(aHeap, iEntryArray[aIndex]);
+}
+COpenFontSessionCacheEntry::Delete(aHeap, iEntryArray[aIndex]);
 iEntryArray.SetAt(aIndex, aEntry);
 aEntry->iLastAccess = iLastAccess++;
 	}
 COpenFontSessionCache::COpenFontSessionCache(TInt aSessionHandle):
 iSessionHandle(aSessionHandle),
 iLastAccess(0)
 {
 }
-/*COpenFontSessionCacheListItem*/
+TInt COpenFontSessionCacheList::AddCache(COpenFontSessionCache* aCache)
-COpenFontSessionCacheListItem::COpenFontSessionCacheListItem(COpenFontSessionCache* aCache):
+	{
-	iNextOffset(NULL)
+	for (TInt index = 0; index < EMaxNumCaches; ++index)
-	{
+		{
-if(aCache != NULL)
+		if (iSessionHandleArray[index] == 0)
-{
+			{
-iCacheOffset = reinterpret_cast<TInt>(aCache) - reinterpret_cast<TInt>(this);
+			iSessionHandleArray[index] = aCache->SessionHandle();
-}
+			iCacheOffsetArray[index] = reinterpret_cast<TInt>(aCache) - reinterpret_cast<TInt>(this);
-else
+			return KErrNone;
-{
+			}
-iCacheOffset = NULL;
+		}
-}
+	return KErrNoMemory;
 	}
-COpenFontSessionCacheListItem::~COpenFontSessionCacheListItem()
+COpenFontSessionCache* COpenFontSessionCacheList::FindCache(TInt aSessionHandle) const
 	{
-	}
+	if (aSessionHandle == 0)
-/** Delete a COpenFontSessionCacheListItem from the passed heap.
-@param aHeap The heap to delete the COpenFontSessionCacheListItem from.
-*/
-void COpenFontSessionCacheListItem::Delete(RHeap* aHeap)
-	{
-COpenFontSessionCache* cache = Cache();
-if (cache != NULL)
-{
-cache->Delete(aHeap);
-aHeap->Free(cache);
-}
-iCacheOffset=NULL;
-iNextOffset=NULL;
-	}
-/** Get the next item to this cache list item.
-@return A pointer to the next item to this one in the session cache, or NULL
-if there is no next item.
-*/
-COpenFontSessionCacheListItem* COpenFontSessionCacheListItem::Next()
-	{
-	if(iNextOffset)
-		{
-		COpenFontSessionCacheListItem* next = reinterpret_cast<COpenFontSessionCacheListItem*>(reinterpret_cast<TInt>(this) + iNextOffset);
-		return next;
-		}
-	else
 		{
 		return NULL;
 		}
-	}
+	for (TInt index = 0; index < EMaxNumCaches; ++index)
+		{
-/** Sets the next item to this in the session cache.
+		if (iSessionHandleArray[index] == aSessionHandle)
+			{
-@param aNext Set this cache list item as the next item to this one in the session cache list.
+			return reinterpret_cast<COpenFontSessionCache*>(reinterpret_cast<TInt>(this) + iCacheOffsetArray[index]);
-*/
+			}
-void COpenFontSessionCacheListItem::SetNext(COpenFontSessionCacheListItem* aNext)
+		}
-	{
+	return NULL;
-	if(aNext != NULL)
-		{
-		iNextOffset = reinterpret_cast<TInt>(aNext) - reinterpret_cast<TInt>(this);
-		}
-	else
-		{
-		iNextOffset = NULL;
-		}
-	}
-/** Get a pointer to the session cache that this cache list item is in.
-@return A pointer to the session cache that this cache list item is part of.
-*/
-COpenFontSessionCache* COpenFontSessionCacheListItem::Cache()
-	{
-	if(iCacheOffset)
-		{
-		COpenFontSessionCache* cache = reinterpret_cast<COpenFontSessionCache*>(reinterpret_cast<TInt>(this) + iCacheOffset);
-		return cache;
-		}
-	else
-		{
-		return NULL;
-		}
-	}
-/** Get a pointer to the first item in the session cache.
-@return A pointer to the first item in the session cache.
-*/
-COpenFontSessionCacheListItem* COpenFontSessionCacheList::Start()
-	{
-	if(iStartOffset)
-		{
-		COpenFontSessionCacheListItem* start = reinterpret_cast<COpenFontSessionCacheListItem*>(reinterpret_cast<TInt>(this) + iStartOffset);
-		return start;
-		}
-	else
-		{
-		return NULL;
-		}
-	}
-/** Set the passed item as the first item in the session cache.
-@param aItem An item to be added to the session cache
-*/
-void COpenFontSessionCacheList::SetStart(COpenFontSessionCacheListItem* aItem)
-	{
-	if(aItem != NULL)
-		{
-		iStartOffset = reinterpret_cast<TInt>(aItem) - reinterpret_cast<TInt>(this);
-		}
-	else
-		{
-		iStartOffset = 0;
-		}
 	}
 /** Delete all the items in the session cache if the current cache session handle
 matches the passed session handle.
 @param aHeap The heap base of the current process.
 @param aSessionHandle The session handle of the cache to be deleted.
 */
 void COpenFontSessionCacheList::DeleteCache(RHeap* aHeap, TInt aSessionHandle)
 	{
-RSemaphore sem;
+	if (aSessionHandle == 0)
-if (KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
+		{
-{
+		return;
-RDebug::Print(_L("COpenFontSessionCacheList::DeleteCache() can't open SessionCacheSemaphore"));
+		}
-return;
+	for (TInt index = 0; index < EMaxNumCaches; ++index)
-}
+		{
+		if (iSessionHandleArray[index] == aSessionHandle)
-COpenFontSessionCacheListItem* prev = NULL;
+			{
-for (COpenFontSessionCacheListItem* curr = Start(); curr; prev = curr, curr
+			COpenFontSessionCache* cache = reinterpret_cast<COpenFontSessionCache*>(PtrAdd(this, iCacheOffsetArray[index]));
-= curr->Next())
+			cache->Delete(aHeap);
-{
+			aHeap->Free(cache);
-COpenFontSessionCache* cache = curr->Cache();
+			iSessionHandleArray[index] = 0;
-if (cache != NULL && cache->iSessionHandle == aSessionHandle)
+			iCacheOffsetArray[index] = 0;
-{
+			return;
-for (TInt i = 0; i < KSessionCacheSemaphoreCount; i++)
+			}
-{
+}
-//coverity[lock]
-//coverity[double_lock]
-sem.Wait();
-}
-if (curr == Start())
-{
-SetStart(curr->Next());
-}
-else
-{
-__ASSERT_DEBUG(prev != NULL, User::Invariant());
-prev->SetNext(curr->Next());
-}
-curr->Delete(aHeap);
-aHeap->Free(curr);
-sem.Signal(KSessionCacheSemaphoreCount);
-sem.Close();
-return;
-}
-}
-sem.Close();
 	}
 /** Delete all the items in the current session cache.
 @param aHeap The heap base of the current process.
 */
 void COpenFontSessionCacheList::Delete(RHeap* aHeap)
 	{
-RSemaphore sem;
+	for (TInt index = 0; index < EMaxNumCaches; ++index)
-if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
+		{
-{
+		if (iCacheOffsetArray[index] != 0)
-RDebug::Print(_L("COpenFontSessionCacheList::Delete() can't open SessionCacheSemaphore"));
+			{
-return;
+			COpenFontSessionCache* cache = reinterpret_cast<COpenFontSessionCache*>(PtrAdd(this, iCacheOffsetArray[index]));
-}
+			cache->Delete(aHeap);
+			aHeap->Free(cache);
-	COpenFontSessionCacheListItem* cur = Start();
+			}
-	COpenFontSessionCacheListItem* next = NULL;
+		}
+	Mem::FillZ(this, sizeof(COpenFontSessionCacheList));
-for(TInt i=0; i<KSessionCacheSemaphoreCount; i++)
-{
-	//coverity[lock]
-	//coverity[double_lock]
-sem.Wait();
-}
-	while (cur != NULL)
-		{
-		next = cur->Next();
-		cur->Delete(aHeap);
-		aHeap->Free(cur);
-		cur = next;
-		}
-sem.Signal(KSessionCacheSemaphoreCount);
-sem.Close();
 	}
 /**
 Delete all glyphs belonging to a particular font.
 */
 void COpenFontSessionCacheList::DeleteFontGlyphs(RHeap* aHeap, const COpenFont* aFont)
 	{
-RSemaphore sem;
+	for (TInt index = 0; index < EMaxNumCaches; ++index)
-if(KErrNone != sem.OpenGlobal(KSessionCacheSemaphoreName))
+		{
-{
+		if (iCacheOffsetArray[index] != 0)
-RDebug::Print(_L("COpenFontSessionCacheList::DeleteFontGlyphs can't global open SessionCacheSemaphore"));
+			{
-return;
+			COpenFontSessionCache* cache = reinterpret_cast<COpenFontSessionCache*>(PtrAdd(this, iCacheOffsetArray[index]));
-}
+			TInt numEntries = cache->iEntryArray.Count();
-sem.Wait();
+			for (TInt i = 0; i < numEntries; ++i)
-	for (COpenFontSessionCacheListItem* p = Start(); p; p = p->Next())
+				{
-{
+				COpenFontSessionCacheEntry* entry = cache->iEntryArray[i];
-COpenFontSessionCache* cache = p->Cache();
+				if (entry != NULL && entry->Font() == aFont)
-if (cache != NULL)
+					{
-{
+					COpenFontSessionCacheEntry::Delete(aHeap, entry);
-TInt entries = cache->iEntryArray.Count();
+					cache->iEntryArray.SetAt(i, NULL);
-for (TInt i = 0; i < entries; ++i)
+					}
-{
+				}
-COpenFontSessionCacheEntry* e = cache->iEntryArray[i];
+			}
-if (e != NULL && e->Font() == aFont)
+}
-{
-COpenFontSessionCacheEntry::Delete(aHeap, e);
-cache->iEntryArray.SetAt(i, NULL);
-}
-}
-} //if(cache != NULL)
-}
-	sem.Signal();
-	sem.Close();
 	}
 /**
 C++ constructor with a CFont parameter.

changeset 46	6124ff6478cc
parent 40	91ef7621b7fc
child 53	11e2bb0d14ba