Whitespace fix: remove whitespace from the end of lines.

src/gl/SkTextureCache.cpp

 #include "SkTextureCache.h"
 
 //#define TRACE_HASH_HITS
 //#define TRACE_TEXTURE_CACHE_PURGE
 
 SkTextureCache::Entry::Entry(const SkBitmap& bitmap)
         : fName(0), fKey(bitmap), fPrev(NULL), fNext(NULL) {
 
     fMemSize = SkGL::ComputeTextureMemorySize(bitmap);
     fLockCount = 0;
@@ skipping 22 matching lines @@
     while (entry) {
         SkASSERT(entry->lockCount() == 0);
         entry = entry->fNext;
     }
 #endif
     this->validate();
 }
 
 void SkTextureCache::deleteAllCaches(bool texturesAreValid) {
     this->validate();
-    
+
     Entry* entry = fHead;
     while (entry) {
         Entry* next = entry->fNext;
         if (!texturesAreValid) {
             entry->abandonTexture();
         }
         SkDELETE(entry);
         entry = next;
     }
-    
+
     fSorted.reset();
     sk_bzero(fHash, sizeof(fHash));
-    
+
     fTexCount = 0;
     fTexSize = 0;
-    
+
     fTail = fHead = NULL;
-    
+
     this->validate();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 int SkTextureCache::findInSorted(const Key& key) const {
     int count = fSorted.count();
     if (count == 0) {
         return ~0;
     }
 
     Entry** sorted = fSorted.begin();
     int lo = 0;
     int hi = count - 1;
     while (lo < hi) {
         int mid = (hi + lo) >> 1;
         if (sorted[mid]->getKey() < key) {
             lo = mid + 1;
         } else {
             hi = mid;
         }
     }
-    
+
     // hi is now our best guess
     const Entry* entry = sorted[hi];
     if (entry->getKey() == key) {
         return hi;
     }
-    
+
     // return where to insert it
     if (entry->getKey() < key) {
         hi += 1;
     }
     return ~hi; // we twiddle to indicate not-found
 }
 
 #ifdef TRACE_HASH_HITS
 static int gHashHits;
 static int gSortedHits;
 #endif
 
 SkTextureCache::Entry* SkTextureCache::find(const Key& key, int* insert) const {
     int count = fSorted.count();
     if (count == 0) {
         *insert = 0;
         return NULL;
     }
 
     // check the hash first
     int hashIndex = key.getHashIndex();
-    Entry* entry = fHash[hashIndex];    
+    Entry* entry = fHash[hashIndex];
     if (NULL != entry && entry->getKey() == key) {
 #ifdef TRACE_HASH_HITS
         gHashHits += 1;
 #endif
         return entry;
     }
-    
+
     int index = this->findInSorted(key);
     if (index >= 0) {
 #ifdef TRACE_HASH_HITS
         gSortedHits += 1;
 #endif
         entry = fSorted[index];
         fHash[hashIndex] = entry;
         return entry;
     }
-    
+
     // ~index is where to insert the entry
     *insert = ~index;
     return NULL;
 }
 
 SkTextureCache::Entry* SkTextureCache::lock(const SkBitmap& bitmap) {
     this->validate();
-    
+
     // call this before we call find(), so we don't reorder after find() and
     // invalidate our index
     this->purgeIfNecessary(SkGL::ComputeTextureMemorySize(bitmap));
 
     Key key(bitmap);
     int index;
     Entry* entry = this->find(key, &index);
 
     if (NULL == entry) {
         entry = SkNEW_ARGS(Entry, (bitmap));
-        
+
         entry->fName = SkGL::BindNewTexture(bitmap, &entry->fTexSize);
         if (0 == entry->fName) {
             SkDELETE(entry);
             return NULL;
         }
         fHash[key.getHashIndex()] = entry;
         *fSorted.insert(index) = entry;
 
         fTexCount += 1;
         fTexSize += entry->memSize();
     } else {
         // detach from our llist
         Entry* prev = entry->fPrev;
         Entry* next = entry->fNext;
         if (prev) {
             prev->fNext = next;
         } else {
             SkASSERT(fHead == entry);
             fHead = next;
         }
         if (next) {
             next->fPrev = prev;
         } else {
             SkASSERT(fTail == entry);
             fTail = prev;
         }
         // now bind the texture
         glBindTexture(GL_TEXTURE_2D, entry->fName);
     }
-    
+
     // add to head of llist for LRU
     entry->fPrev = NULL;
     entry->fNext = fHead;
     if (NULL != fHead) {
         SkASSERT(NULL == fHead->fPrev);
         fHead->fPrev = entry;
     }
     fHead = entry;
     if (NULL == fTail) {
         fTail = entry;
     }
-    
+
     this->validate();
     entry->lock();
-    
+
 #ifdef TRACE_HASH_HITS
     SkDebugf("---- texture cache hash=%d sorted=%d\n", gHashHits, gSortedHits);
 #endif
     return entry;
 }
 
 void SkTextureCache::unlock(Entry* entry) {
     this->validate();
 
 #ifdef SK_DEBUG
     SkASSERT(entry);
     int index = this->findInSorted(entry->getKey());
     SkASSERT(fSorted[index] == entry);
 #endif
 
     SkASSERT(entry->fLockCount > 0);
     entry->unlock();
 }
 
 void SkTextureCache::purgeIfNecessary(size_t extraSize) {
     this->validate();
 
     size_t countMax = fTexCountMax;
     size_t sizeMax = fTexSizeMax;
-    
+
     // take extraSize into account, but watch for underflow of size_t
     if (extraSize > sizeMax) {
         sizeMax = 0;
     } else {
         sizeMax -= extraSize;
     }
 
     Entry* entry = fTail;
     while (entry) {
         if (fTexCount <= countMax && fTexSize <= sizeMax) {
@@ skipping 24 matching lines @@
         if (prev) {
             prev->fNext = next;
         } else {
             fHead = next;
         }
         if (next) {
             next->fPrev = prev;
         } else {
             fTail = prev;
         }
-        
+
         // now delete it
 #ifdef TRACE_TEXTURE_CACHE_PURGE
         SkDebugf("---- purge texture cache %d size=%d\n",
                  entry->name(), entry->memSize());
 #endif
         SkDELETE(entry);
-        
+
         // keep going
         entry = prev;
     }
 
     this->validate();
 }
 
 void SkTextureCache::setMaxCount(size_t count) {
     if (fTexCountMax != count) {
         fTexCountMax = count;
@@ skipping 15 matching lines @@
     if (0 == fTexCount) {
         SkASSERT(0 == fTexSize);
         SkASSERT(NULL == fHead);
         SkASSERT(NULL == fTail);
         return;
     }
 
     SkASSERT(fTexSize); // do we allow a zero-sized texture?
     SkASSERT(fHead);
     SkASSERT(fTail);
-    
+
     SkASSERT(NULL == fHead->fPrev);
     SkASSERT(NULL == fTail->fNext);
     if (1 == fTexCount) {
         SkASSERT(fHead == fTail);
     }
 
     const Entry* entry = fHead;
     size_t count = 0;
     size_t size = 0;
     size_t i;
@@ skipping 19 matching lines @@
         SkASSERT(size < fTexSize);
         size += entry->memSize();
         count += 1;
         if (NULL == entry->fPrev) {
             SkASSERT(fHead == entry);
         }
         entry = entry->fPrev;
     }
     SkASSERT(count == fTexCount);
     SkASSERT(size == fTexSize);
-    
+
     SkASSERT(count == (size_t)fSorted.count());
     for (i = 1; i < count; i++) {
         SkASSERT(fSorted[i-1]->getKey() < fSorted[i]->getKey());
     }
-    
+
     for (i = 0; i < kHashCount; i++) {
         if (fHash[i]) {
             size_t index = fHash[i]->getKey().getHashIndex();
             SkASSERT(index == i);
             index = fSorted.find(fHash[i]);
             SkASSERT((size_t)index < count);
         }
     }
 }
 #endif