The Tor Browser: gfx/skia/trunk/src/lazy/SkDiscardableMemoryPool.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/lazy/SkDiscardableMemoryPool.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/lazy/SkDiscardableMemoryPool.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkDiscardableMemoryPool.h"
 #include "SkOnce.h"
 // Note:
 // A PoolDiscardableMemory is memory that is counted in a pool.
 // A DiscardableMemoryPool is a pool of PoolDiscardableMemorys.
 /**
  *  A SkPoolDiscardableMemory is a SkDiscardableMemory that relies on
  *  a SkDiscardableMemoryPool object to manage the memory.
  */
 class SkPoolDiscardableMemory : public SkDiscardableMemory {
 public:
     SkPoolDiscardableMemory(SkDiscardableMemoryPool* pool,
                             void* pointer, size_t bytes);
     virtual ~SkPoolDiscardableMemory();
     virtual bool lock() SK_OVERRIDE;
     virtual void* data() SK_OVERRIDE;
     virtual void unlock() SK_OVERRIDE;
     friend class SkDiscardableMemoryPool;
 private:
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(SkPoolDiscardableMemory);
     SkDiscardableMemoryPool* const fPool;
     bool                           fLocked;
     void*                          fPointer;
     const size_t                   fBytes;
 };
 SkPoolDiscardableMemory::SkPoolDiscardableMemory(SkDiscardableMemoryPool* pool,
                                                  void* pointer,
                                                  size_t bytes)
     : fPool(pool)
     , fLocked(true)
     , fPointer(pointer)
     , fBytes(bytes) {
     SkASSERT(fPool != NULL);
     SkASSERT(fPointer != NULL);
     SkASSERT(fBytes > 0);
     fPool->ref();
 }
 SkPoolDiscardableMemory::~SkPoolDiscardableMemory() {
     SkASSERT(!fLocked); // contract for SkDiscardableMemory
     fPool->free(this);
     fPool->unref();
 }
 bool SkPoolDiscardableMemory::lock() {
     SkASSERT(!fLocked); // contract for SkDiscardableMemory
     return fPool->lock(this);
 }
 void* SkPoolDiscardableMemory::data() {
     SkASSERT(fLocked); // contract for SkDiscardableMemory
     return fPointer;
 }
 void SkPoolDiscardableMemory::unlock() {
     SkASSERT(fLocked); // contract for SkDiscardableMemory
     fPool->unlock(this);
 }
 ////////////////////////////////////////////////////////////////////////////////
 SkDiscardableMemoryPool::SkDiscardableMemoryPool(size_t budget,
                                                  SkBaseMutex* mutex)
     : fMutex(mutex)
     , fBudget(budget)
     , fUsed(0) {
     #if LAZY_CACHE_STATS
     fCacheHits = 0;
     fCacheMisses = 0;
     #endif  // LAZY_CACHE_STATS
 }
 SkDiscardableMemoryPool::~SkDiscardableMemoryPool() {
     // SkPoolDiscardableMemory objects that belong to this pool are
     // always deleted before deleting this pool since each one has a
     // ref to the pool.
     SkASSERT(fList.isEmpty());
 }
 void SkDiscardableMemoryPool::dumpDownTo(size_t budget) {
     // assert((NULL = fMutex) || fMutex->isLocked());
     // TODO(halcanary) implement bool fMutex::isLocked().
     // WARNING: only call this function after aquiring lock.
     if (fUsed <= budget) {
         return;
     }
     typedef SkTInternalLList<SkPoolDiscardableMemory>::Iter Iter;
     Iter iter;
     SkPoolDiscardableMemory* cur = iter.init(fList, Iter::kTail_IterStart);
     while ((fUsed > budget) && (NULL != cur)) {
         if (!cur->fLocked) {
             SkPoolDiscardableMemory* dm = cur;
             SkASSERT(dm->fPointer != NULL);
             sk_free(dm->fPointer);
             dm->fPointer = NULL;
             SkASSERT(fUsed >= dm->fBytes);
             fUsed -= dm->fBytes;
             cur = iter.prev();
             // Purged DMs are taken out of the list.  This saves times
             // looking them up.  Purged DMs are NOT deleted.
             fList.remove(dm);
         } else {
             cur = iter.prev();
         }
     }
 }
 SkDiscardableMemory* SkDiscardableMemoryPool::create(size_t bytes) {
     void* addr = sk_malloc_flags(bytes, 0);
     if (NULL == addr) {
         return NULL;
     }
     SkPoolDiscardableMemory* dm = SkNEW_ARGS(SkPoolDiscardableMemory,
                                              (this, addr, bytes));
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     fList.addToHead(dm);
     fUsed += bytes;
     this->dumpDownTo(fBudget);
     return dm;
 }
 void SkDiscardableMemoryPool::free(SkPoolDiscardableMemory* dm) {
     // This is called by dm's destructor.
     if (dm->fPointer != NULL) {
         SkAutoMutexAcquire autoMutexAcquire(fMutex);
         sk_free(dm->fPointer);
         dm->fPointer = NULL;
         SkASSERT(fUsed >= dm->fBytes);
         fUsed -= dm->fBytes;
         fList.remove(dm);
     } else {
         SkASSERT(!fList.isInList(dm));
     }
 }
 bool SkDiscardableMemoryPool::lock(SkPoolDiscardableMemory* dm) {
     SkASSERT(dm != NULL);
     if (NULL == dm->fPointer) {
         #if LAZY_CACHE_STATS
         SkAutoMutexAcquire autoMutexAcquire(fMutex);
         ++fCacheMisses;
         #endif  // LAZY_CACHE_STATS
         return false;
     }
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     if (NULL == dm->fPointer) {
         // May have been purged while waiting for lock.
         #if LAZY_CACHE_STATS
         ++fCacheMisses;
         #endif  // LAZY_CACHE_STATS
         return false;
     }
     dm->fLocked = true;
     fList.remove(dm);
     fList.addToHead(dm);
     #if LAZY_CACHE_STATS
     ++fCacheHits;
     #endif  // LAZY_CACHE_STATS
     return true;
 }
 void SkDiscardableMemoryPool::unlock(SkPoolDiscardableMemory* dm) {
     SkASSERT(dm != NULL);
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     dm->fLocked = false;
     this->dumpDownTo(fBudget);
 }
 size_t SkDiscardableMemoryPool::getRAMUsed() {
     return fUsed;
 }
 void SkDiscardableMemoryPool::setRAMBudget(size_t budget) {
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     fBudget = budget;
     this->dumpDownTo(fBudget);
 }
 void SkDiscardableMemoryPool::dumpPool() {
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     this->dumpDownTo(0);
 }
 ////////////////////////////////////////////////////////////////////////////////
 SK_DECLARE_STATIC_MUTEX(gMutex);
 static void create_pool(SkDiscardableMemoryPool** pool) {
     SkASSERT(NULL == *pool);
     *pool = SkNEW_ARGS(SkDiscardableMemoryPool,
                        (SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE,
                         &gMutex));
 }
 SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() {
     static SkDiscardableMemoryPool* gPool(NULL);
     SK_DECLARE_STATIC_ONCE(create_pool_once);
     SkOnce(&create_pool_once, create_pool, &gPool);
     SkASSERT(NULL != gPool);
     return gPool;
 }
 ////////////////////////////////////////////////////////////////////////////////

The Tor Browser / annotate

gfx/skia/trunk/src/lazy/SkDiscardableMemoryPool.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/lazy/SkDiscardableMemoryPool.cpp