2 files changed, 33 insertions, 22 deletions

diff --git a/linden/indra/newview/lltexturecache.cpp b/linden/indra/newview/lltexturecache.cpp
index a9b7f81..a1a9a39 100644
--- a/linden/indra/newview/lltexturecache.cpp
+++ b/linden/indra/newview/lltexturecache.cpp
@@ -1172,7 +1172,7 @@ void LLTextureCache::readHeaderCache()
                         U32 empty_entries = 0;
                         typedef std::pair<U32, LLUUID> lru_data_t;
                         std::set<lru_data_t> lru;
-                        std::vector<LLUUID> purge_list;
+                        std::set<LLUUID> purge_list;
                         for (U32 i=0; i<num_entries; i++)
                         {
                                 Entry& entry = entries[i];
@@ -1191,27 +1191,23 @@ void LLTextureCache::readHeaderCache()
                                                 {
                                                         // Shouldn't happen, failsafe only
                                                         llwarns << "Bad entry: " << i << ": " << entry.mID << ": BodySize: " << entry.mBodySize << llendl;
-                                                        purge_list.push_back(id);
+                                                        purge_list.insert(id);
                                                 }
                                         }
                                 }
                         }
-                        if (num_entries > sCacheMaxEntries)
+                        if (num_entries - empty_entries > sCacheMaxEntries)
                         {
                                 // Special case: cache size was reduced, need to remove entries
                                 // Note: After we prune entries, we will call this again and create the LRU
-                                U32 entries_to_purge = (num_entries-empty_entries) - sCacheMaxEntries;
+                                U32 entries_to_purge = (num_entries - empty_entries) - sCacheMaxEntries;
                                 llinfos << "Texture Cache Entries: " << num_entries << " Max: " << sCacheMaxEntries << " Empty: " << empty_entries << " Purging: " << entries_to_purge << llendl;
-                                if (entries_to_purge > 0)
+                                // We can exit the following loop with the given condition, since if we'd reach the end of the lru set we'd have:
+                                // purge_list.size() = lru.size() = num_entries - empty_entries = entries_to_purge + sCacheMaxEntries >= entries_to_purge
+                                for (std::set<lru_data_t>::iterator iter = lru.begin(); purge_list.size() < entries_to_purge; ++iter)
                                 {
-                                        for (std::set<lru_data_t>::iterator iter = lru.begin(); iter != lru.end(); ++iter)
-                                        {
-                                                purge_list.push_back(iter->second);
-                                                if (purge_list.size() >= entries_to_purge)
-                                                        break;
-                                        }
+                                        purge_list.insert(iter->second);
                                 }
-                                llassert_always(purge_list.size() >= entries_to_purge);
                         }
                         else
                         {
@@ -1227,11 +1223,9 @@ void LLTextureCache::readHeaderCache()
                         
                         if (purge_list.size() > 0)
                         {
-                                for (std::vector<LLUUID>::iterator iter = purge_list.begin(); iter != purge_list.end(); ++iter)
+                                for (std::set<LLUUID>::iterator iter = purge_list.begin(); iter != purge_list.end(); ++iter)
                                 {
-                                        mHeaderMutex.unlock(); 
-                                        removeFromCache(*iter);
-                                        mHeaderMutex.lock();
+                                        removeFromCacheLocked(*iter);
                                 }
                                 // If we removed any entries, we need to rebuild the entries list,
                                 // write the header, and call this again
@@ -1250,7 +1244,7 @@ void LLTextureCache::readHeaderCache()
                                 writeEntriesAndClose(new_entries);
                                 mHeaderMutex.unlock(); // unlock the mutex before calling again
                                 readHeaderCache(); // repeat with new entries file
-                                mHeaderMutex.lock();
+                                return;
                         }
                         else
                         {
@@ -1345,7 +1339,7 @@ void LLTextureCache::purgeTextures(bool validate)
         if (validate)
         {
                 validate_idx = gSavedSettings.getU32("CacheValidateCounter");
-                U32 next_idx = (++validate_idx) % 256;
+                U32 next_idx = (validate_idx + 1) % 256;
                 gSavedSettings.setU32("CacheValidateCounter", next_idx);
                 LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Validating: " << validate_idx << LL_ENDL;
         }
@@ -1388,7 +1382,15 @@ void LLTextureCache::purgeTextures(bool validate)
                 {
                         purge_count++;
                         LL_DEBUGS("TextureCache") << "PURGING: " << filename << LL_ENDL;
-                        LLAPRFile::remove(filename);
+                        if (entries[idx].mBodySize > 0)
+                        {
+                                LLAPRFile::remove(filename);
+                        }
+                        else if (LLAPRFile::isExist(filename))  // Sanity check. Shouldn't exist.
+                        {
+                                LL_WARNS("TextureCache") << "Entry has zero body size but existing " << filename << ". Deleting file too..." << LL_ENDL;
+                                LLAPRFile::remove(filename);
+                        }
                         cache_size -= entries[idx].mBodySize;
                         mTexturesSizeTotal -= entries[idx].mBodySize;
                         entries[idx].mBodySize = 0;
@@ -1615,7 +1617,6 @@ bool LLTextureCache::removeHeaderCacheEntry(const LLUUID& id)
 {
         if (!mReadOnly)
         {
-                LLMutexLock lock(&mHeaderMutex);
                 Entry entry;
                 S32 idx = openAndReadEntry(id, entry, false);
                 if (idx >= 0)
@@ -1632,17 +1633,26 @@ bool LLTextureCache::removeHeaderCacheEntry(const LLUUID& id)
         return false;
 }
 
-void LLTextureCache::removeFromCache(const LLUUID& id)
+void LLTextureCache::removeFromCacheLocked(const LLUUID& id)
 {
         //llwarns << "Removing texture from cache: " << id << llendl;
         if (!mReadOnly)
         {
                 removeHeaderCacheEntry(id);
-                LLMutexLock lock(&mHeaderMutex);
                 LLAPRFile::remove(getTextureFileName(id));
         }
 }
 
+void LLTextureCache::removeFromCache(const LLUUID& id)
+{
+        //llwarns << "Removing texture from cache: " << id << llendl;
+        if (!mReadOnly)
+        {
+                LLMutexLock lock(&mHeaderMutex);
+                LLTextureCache::removeFromCacheLocked(id);
+        }
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 LLTextureCache::ReadResponder::ReadResponder()
diff --git a/linden/indra/newview/lltexturecache.h b/linden/indra/newview/lltexturecache.h
index 45804c2..c859b9a 100644
--- a/linden/indra/newview/lltexturecache.h
+++ b/linden/indra/newview/lltexturecache.h
@@ -158,6 +158,7 @@ private:
         S32 getHeaderCacheEntry(const LLUUID& id, S32& imagesize);
         S32 setHeaderCacheEntry(const LLUUID& id, S32 imagesize);
         bool removeHeaderCacheEntry(const LLUUID& id);
+        void removeFromCacheLocked(const LLUUID& id);
         
 private:
         // Internal