The Tor Browser: netwerk/cache/nsCacheEntryDescriptor.cpp@6474c204b198 (annotated)

netwerk/cache/nsCacheEntryDescriptor.cpp@6474c204b198 (annotated)

netwerk/cache/nsCacheEntryDescriptor.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsICache.h"
 #include "nsCache.h"
 #include "nsCacheService.h"
 #include "nsCacheEntryDescriptor.h"
 #include "nsCacheEntry.h"
 #include "nsReadableUtils.h"
 #include "nsIOutputStream.h"
 #include "nsCRT.h"
 #include "nsThreadUtils.h"
 #include <algorithm>
 #define kMinDecompressReadBufLen 1024
 #define kMinCompressWriteBufLen  1024
 /******************************************************************************
  * nsAsyncDoomEvent
  *****************************************************************************/
 class nsAsyncDoomEvent : public nsRunnable {
 public:
     nsAsyncDoomEvent(nsCacheEntryDescriptor *descriptor,
                      nsICacheListener *listener)
     {
         mDescriptor = descriptor;
         mListener = listener;
         mThread = do_GetCurrentThread();
         // We addref the listener here and release it in nsNotifyDoomListener
         // on the callers thread. If posting of nsNotifyDoomListener event fails
         // we leak the listener which is better than releasing it on a wrong
         // thread.
         NS_IF_ADDREF(mListener);
     }
     NS_IMETHOD Run()
     {
         nsresult status = NS_OK;
         {
             nsCacheServiceAutoLock lock(LOCK_TELEM(NSASYNCDOOMEVENT_RUN));
             if (mDescriptor->mCacheEntry) {
                 status = nsCacheService::gService->DoomEntry_Internal(
                              mDescriptor->mCacheEntry, true);
             } else if (!mDescriptor->mDoomedOnClose) {
                 status = NS_ERROR_NOT_AVAILABLE;
             }
         }
         if (mListener) {
             mThread->Dispatch(new nsNotifyDoomListener(mListener, status),
                               NS_DISPATCH_NORMAL);
             // posted event will release the reference on the correct thread
             mListener = nullptr;
         }
         return NS_OK;
     }
 private:
     nsRefPtr<nsCacheEntryDescriptor> mDescriptor;
     nsICacheListener                *mListener;
     nsCOMPtr<nsIThread>              mThread;
 };
 NS_IMPL_ISUPPORTS(nsCacheEntryDescriptor,
                   nsICacheEntryDescriptor,
                   nsICacheEntryInfo)
 nsCacheEntryDescriptor::nsCacheEntryDescriptor(nsCacheEntry * entry,
                                                nsCacheAccessMode accessGranted)
     : mCacheEntry(entry),
       mAccessGranted(accessGranted),
       mOutputWrapper(nullptr),
       mLock("nsCacheEntryDescriptor.mLock"),
       mAsyncDoomPending(false),
       mDoomedOnClose(false),
       mClosingDescriptor(false)
 {
     PR_INIT_CLIST(this);
     NS_ADDREF(nsCacheService::GlobalInstance());  // ensure it lives for the lifetime of the descriptor
 }
 nsCacheEntryDescriptor::~nsCacheEntryDescriptor()
 {
     // No need to close if the cache entry has already been severed.  This
     // helps avoid a shutdown assertion (bug 285519) that is caused when
     // consumers end up holding onto these objects past xpcom-shutdown.  It's
     // okay for them to do that because the cache service calls our Close
     // method during xpcom-shutdown, so we don't need to complain about it.
     if (mCacheEntry)
         Close();
     NS_ASSERTION(mInputWrappers.Count() == 0,
                  "We have still some input wrapper!");
     NS_ASSERTION(!mOutputWrapper, "We have still an output wrapper!");
     nsCacheService * service = nsCacheService::GlobalInstance();
     NS_RELEASE(service);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetClientID(char ** result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCLIENTID));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     return ClientIDFromCacheKey(*(mCacheEntry->Key()), result);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetDeviceID(char ** aDeviceID)
 {
     NS_ENSURE_ARG_POINTER(aDeviceID);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDEVICEID));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     const char* deviceID = mCacheEntry->GetDeviceID();
     if (!deviceID) {
         *aDeviceID = nullptr;
         return NS_OK;
     }
     *aDeviceID = NS_strdup(deviceID);
     return *aDeviceID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetKey(nsACString &result)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETKEY));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     return ClientKeyFromCacheKey(*(mCacheEntry->Key()), result);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetFetchCount(int32_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFETCHCOUNT));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->FetchCount();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetLastFetched(uint32_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTFETCHED));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->LastFetched();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetLastModified(uint32_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTMODIFIED));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->LastModified();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetExpirationTime(uint32_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETEXPIRATIONTIME));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->ExpirationTime();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::SetExpirationTime(uint32_t expirationTime)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETEXPIRATIONTIME));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     mCacheEntry->SetExpirationTime(expirationTime);
     mCacheEntry->MarkEntryDirty();
     return NS_OK;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(bool *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_ISSTREAMBASED));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->IsStreamData();
     return NS_OK;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::GetPredictedDataSize(int64_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETPREDICTEDDATASIZE));
     if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->PredictedDataSize();
     return NS_OK;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::SetPredictedDataSize(int64_t
                                                            predictedSize)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETPREDICTEDDATASIZE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     mCacheEntry->SetPredictedDataSize(predictedSize);
     return NS_OK;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(uint32_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDATASIZE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     const char* val = mCacheEntry->GetMetaDataElement("uncompressed-len");
     if (!val) {
         *result = mCacheEntry->DataSize();
     } else {
         *result = atol(val);
     }
     return NS_OK;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::GetStorageDataSize(uint32_t *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEDATASIZE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->DataSize();
     return NS_OK;
 }
 nsresult
 nsCacheEntryDescriptor::RequestDataSizeChange(int32_t deltaSize)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_REQUESTDATASIZECHANGE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     nsresult  rv;
     rv = nsCacheService::OnDataSizeChange(mCacheEntry, deltaSize);
     if (NS_SUCCEEDED(rv)) {
         // XXX review for signed/unsigned math errors
         uint32_t  newDataSize = mCacheEntry->DataSize() + deltaSize;
         mCacheEntry->SetDataSize(newDataSize);
         mCacheEntry->TouchData();
     }
     return rv;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::SetDataSize(uint32_t dataSize)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETDATASIZE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     // XXX review for signed/unsigned math errors
     int32_t  deltaSize = dataSize - mCacheEntry->DataSize();
     nsresult  rv;
     rv = nsCacheService::OnDataSizeChange(mCacheEntry, deltaSize);
     // this had better be NS_OK, this call instance is advisory for memory cache objects
     if (NS_SUCCEEDED(rv)) {
         // XXX review for signed/unsigned math errors
         uint32_t  newDataSize = mCacheEntry->DataSize() + deltaSize;
         mCacheEntry->SetDataSize(newDataSize);
         mCacheEntry->TouchData();
     } else {
         NS_WARNING("failed SetDataSize() on memory cache object!");
     }
     return rv;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::OpenInputStream(uint32_t offset, nsIInputStream ** result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsInputStreamWrapper* cacheInput = nullptr;
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENINPUTSTREAM));
         if (!mCacheEntry)                  return NS_ERROR_NOT_AVAILABLE;
         if (!mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
         // Don't open any new stream when closing descriptor or clearing entries
         if (mClosingDescriptor || nsCacheService::GetClearingEntries())
             return NS_ERROR_NOT_AVAILABLE;
         // ensure valid permissions
         if (!(mAccessGranted & nsICache::ACCESS_READ))
             return NS_ERROR_CACHE_READ_ACCESS_DENIED;
         const char *val;
         val = mCacheEntry->GetMetaDataElement("uncompressed-len");
         if (val) {
             cacheInput = new nsDecompressInputStreamWrapper(this, offset);
         } else {
             cacheInput = new nsInputStreamWrapper(this, offset);
         }
         if (!cacheInput) return NS_ERROR_OUT_OF_MEMORY;
         mInputWrappers.AppendElement(cacheInput);
     }
     NS_ADDREF(*result = cacheInput);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::OpenOutputStream(uint32_t offset, nsIOutputStream ** result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsOutputStreamWrapper* cacheOutput = nullptr;
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENOUTPUTSTREAM));
         if (!mCacheEntry)                  return NS_ERROR_NOT_AVAILABLE;
         if (!mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
         // Don't open any new stream when closing descriptor or clearing entries
         if (mClosingDescriptor || nsCacheService::GetClearingEntries())
             return NS_ERROR_NOT_AVAILABLE;
         // ensure valid permissions
         if (!(mAccessGranted & nsICache::ACCESS_WRITE))
             return NS_ERROR_CACHE_WRITE_ACCESS_DENIED;
         int32_t compressionLevel = nsCacheService::CacheCompressionLevel();
         const char *val;
         val = mCacheEntry->GetMetaDataElement("uncompressed-len");
         if ((compressionLevel > 0) && val) {
             cacheOutput = new nsCompressOutputStreamWrapper(this, offset);
         } else {
             // clear compression flag when compression disabled - see bug 715198
             if (val) {
                 mCacheEntry->SetMetaDataElement("uncompressed-len", nullptr);
             }
             cacheOutput = new nsOutputStreamWrapper(this, offset);
         }
         if (!cacheOutput) return NS_ERROR_OUT_OF_MEMORY;
         mOutputWrapper = cacheOutput;
     }
     NS_ADDREF(*result = cacheOutput);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetCacheElement(nsISupports ** result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCACHEELEMENT));
     if (!mCacheEntry)                 return NS_ERROR_NOT_AVAILABLE;
     if (mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_STREAM;
     NS_IF_ADDREF(*result = mCacheEntry->Data());
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::SetCacheElement(nsISupports * cacheElement)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETCACHEELEMENT));
     if (!mCacheEntry)                 return NS_ERROR_NOT_AVAILABLE;
     if (mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_STREAM;
     return nsCacheService::SetCacheElement(mCacheEntry, cacheElement);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetAccessGranted(nsCacheAccessMode *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     *result = mAccessGranted;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy *result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEPOLICY));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->StoragePolicy();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::SetStoragePolicy(nsCacheStoragePolicy policy)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSTORAGEPOLICY));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     // XXX validate policy against session?
     bool        storageEnabled = false;
     storageEnabled = nsCacheService::IsStorageEnabledForPolicy_Locked(policy);
     if (!storageEnabled)    return NS_ERROR_FAILURE;
     // Don't change the storage policy of entries we can't write
     if (!(mAccessGranted & nsICache::ACCESS_WRITE))
         return NS_ERROR_NOT_AVAILABLE;
     // Don't allow a cache entry to move from memory-only to anything else
     if (mCacheEntry->StoragePolicy() == nsICache::STORE_IN_MEMORY &&
         policy != nsICache::STORE_IN_MEMORY)
         return NS_ERROR_NOT_AVAILABLE;
     mCacheEntry->SetStoragePolicy(policy);
     mCacheEntry->MarkEntryDirty();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetFile(nsIFile ** result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFILE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     return nsCacheService::GetFileForEntry(mCacheEntry, result);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetSecurityInfo(nsISupports ** result)
 {
     NS_ENSURE_ARG_POINTER(result);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSECURITYINFO));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     *result = mCacheEntry->SecurityInfo();
     NS_IF_ADDREF(*result);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::SetSecurityInfo(nsISupports * securityInfo)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSECURITYINFO));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     mCacheEntry->SetSecurityInfo(securityInfo);
     mCacheEntry->MarkEntryDirty();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::Doom()
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOM));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     return nsCacheService::DoomEntry(mCacheEntry);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::DoomAndFailPendingRequests(nsresult status)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOMANDFAILPENDINGREQUESTS));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::AsyncDoom(nsICacheListener *listener)
 {
     bool asyncDoomPending;
     {
         mozilla::MutexAutoLock lock(mLock);
         asyncDoomPending = mAsyncDoomPending;
         mAsyncDoomPending = true;
     }
     if (asyncDoomPending) {
         // AsyncDoom was already called. Notify listener if it is non-null,
         // otherwise just return success.
         if (listener) {
             nsresult rv = NS_DispatchToCurrentThread(
                 new nsNotifyDoomListener(listener, NS_ERROR_NOT_AVAILABLE));
             if (NS_SUCCEEDED(rv))
                 NS_IF_ADDREF(listener);
             return rv;
         }
         return NS_OK;
     }
     nsRefPtr<nsIRunnable> event = new nsAsyncDoomEvent(this, listener);
     return nsCacheService::DispatchToCacheIOThread(event);
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::MarkValid()
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_MARKVALID));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     nsresult  rv = nsCacheService::ValidateEntry(mCacheEntry);
     return rv;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::Close()
 {
     nsRefPtr<nsOutputStreamWrapper> outputWrapper;
     nsTArray<nsRefPtr<nsInputStreamWrapper> > inputWrappers;
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE));
         if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
         // Make sure no other stream can be opened
         mClosingDescriptor = true;
         outputWrapper = mOutputWrapper;
         for (int32_t i = 0 ; i < mInputWrappers.Count() ; i++)
             inputWrappers.AppendElement(static_cast<nsInputStreamWrapper *>(
                         mInputWrappers[i]));
     }
     // Call Close() on the streams outside the lock since it might need to call
     // methods that grab the cache service lock, e.g. compressed output stream
     // when it finalizes the entry
     if (outputWrapper) {
         if (NS_FAILED(outputWrapper->Close())) {
             NS_WARNING("Dooming entry because Close() failed!!!");
             Doom();
         }
         outputWrapper = nullptr;
     }
     for (uint32_t i = 0 ; i < inputWrappers.Length() ; i++)
         inputWrappers[i]->Close();
     inputWrappers.Clear();
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE));
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     // XXX perhaps closing descriptors should clear/sever transports
     // tell nsCacheService we're going away
     nsCacheService::CloseDescriptor(this);
     NS_ASSERTION(mCacheEntry == nullptr, "mCacheEntry not null");
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::GetMetaDataElement(const char *key, char **result)
 {
     NS_ENSURE_ARG_POINTER(key);
     *result = nullptr;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETMETADATAELEMENT));
     NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE);
     const char *value;
     value = mCacheEntry->GetMetaDataElement(key);
     if (!value) return NS_ERROR_NOT_AVAILABLE;
     *result = NS_strdup(value);
     if (!*result) return NS_ERROR_OUT_OF_MEMORY;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::SetMetaDataElement(const char *key, const char *value)
 {
     NS_ENSURE_ARG_POINTER(key);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETMETADATAELEMENT));
     NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE);
     // XXX allow null value, for clearing key?
     nsresult rv = mCacheEntry->SetMetaDataElement(key, value);
     if (NS_SUCCEEDED(rv))
         mCacheEntry->TouchMetaData();
     return rv;
 }
 NS_IMETHODIMP
 nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor * visitor)
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_VISITMETADATA));
     // XXX check callers, we're calling out of module
     NS_ENSURE_ARG_POINTER(visitor);
     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
     return mCacheEntry->VisitMetaDataElements(visitor);
 }
 /******************************************************************************
  * nsCacheInputStream - a wrapper for nsIInputStream keeps the cache entry
  *                      open while referenced.
  ******************************************************************************/
 NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsInputStreamWrapper)
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsCacheEntryDescriptor::nsInputStreamWrapper::Release()
 {
     // Holding a reference to descriptor ensures that cache service won't go
     // away. Do not grab cache service lock if there is no descriptor.
     nsRefPtr<nsCacheEntryDescriptor> desc;
     {
         mozilla::MutexAutoLock lock(mLock);
         desc = mDescriptor;
     }
     if (desc)
         nsCacheService::Lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_RELEASE));
     nsrefcnt count;
     NS_PRECONDITION(0 != mRefCnt, "dup release");
     count = --mRefCnt;
     NS_LOG_RELEASE(this, count, "nsCacheEntryDescriptor::nsInputStreamWrapper");
     if (0 == count) {
         // don't use desc here since mDescriptor might be already nulled out
         if (mDescriptor) {
             NS_ASSERTION(mDescriptor->mInputWrappers.IndexOf(this) != -1,
                          "Wrapper not found in array!");
             mDescriptor->mInputWrappers.RemoveElement(this);
         }
         if (desc)
             nsCacheService::Unlock();
         mRefCnt = 1;
         delete (this);
         return 0;
     }
     if (desc)
         nsCacheService::Unlock();
     return count;
 }
 NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsInputStreamWrapper)
   NS_INTERFACE_MAP_ENTRY(nsIInputStream)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END_THREADSAFE
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::LazyInit()
 {
     // Check if we have the descriptor. If not we can't even grab the cache
     // lock since it is not ensured that the cache service still exists.
     if (!mDescriptor)
         return NS_ERROR_NOT_AVAILABLE;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_LAZYINIT));
     nsCacheAccessMode mode;
     nsresult rv = mDescriptor->GetAccessGranted(&mode);
     if (NS_FAILED(rv)) return rv;
     NS_ENSURE_TRUE(mode & nsICache::ACCESS_READ, NS_ERROR_UNEXPECTED);
     nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
     if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
     rv = nsCacheService::OpenInputStreamForEntry(cacheEntry, mode,
                                                  mStartOffset,
                                                  getter_AddRefs(mInput));
     CACHE_LOG_DEBUG(("nsInputStreamWrapper::LazyInit "
                       "[entry=%p, wrapper=%p, mInput=%p, rv=%d]",
                       mDescriptor, this, mInput.get(), int(rv)));
     if (NS_FAILED(rv)) return rv;
     mInitialized = true;
     return NS_OK;
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::EnsureInit()
 {
     if (mInitialized) {
         NS_ASSERTION(mDescriptor, "Bad state");
         return NS_OK;
     }
     return LazyInit();
 }
 void nsCacheEntryDescriptor::
 nsInputStreamWrapper::CloseInternal()
 {
     mLock.AssertCurrentThreadOwns();
     if (!mDescriptor) {
         NS_ASSERTION(!mInitialized, "Bad state");
         NS_ASSERTION(!mInput, "Bad state");
         return;
     }
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_CLOSEINTERNAL));
     if (mDescriptor) {
         mDescriptor->mInputWrappers.RemoveElement(this);
         nsCacheService::ReleaseObject_Locked(mDescriptor);
         mDescriptor = nullptr;
     }
     mInitialized = false;
     mInput = nullptr;
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::Close()
 {
     mozilla::MutexAutoLock lock(mLock);
     return Close_Locked();
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::Close_Locked()
 {
     nsresult rv = EnsureInit();
     if (NS_SUCCEEDED(rv)) {
         rv = mInput->Close();
     } else {
         NS_ASSERTION(!mInput,
                      "Shouldn't have mInput when EnsureInit() failed");
     }
     // Call CloseInternal() even when EnsureInit() failed, e.g. in case we are
     // closing streams with nsCacheService::CloseAllStream()
     CloseInternal();
     return rv;
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::Available(uint64_t *avail)
 {
     mozilla::MutexAutoLock lock(mLock);
     nsresult rv = EnsureInit();
     if (NS_FAILED(rv)) return rv;
     return mInput->Available(avail);
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::Read(char *buf, uint32_t count, uint32_t *countRead)
 {
     mozilla::MutexAutoLock lock(mLock);
     return Read_Locked(buf, count, countRead);
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::Read_Locked(char *buf, uint32_t count, uint32_t *countRead)
 {
     nsresult rv = EnsureInit();
     if (NS_SUCCEEDED(rv))
         rv = mInput->Read(buf, count, countRead);
     CACHE_LOG_DEBUG(("nsInputStreamWrapper::Read "
                       "[entry=%p, wrapper=%p, mInput=%p, rv=%d]",
                       mDescriptor, this, mInput.get(), rv));
     return rv;
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::ReadSegments(nsWriteSegmentFun writer, void *closure,
                                    uint32_t count, uint32_t *countRead)
 {
     // cache stream not buffered
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 nsresult nsCacheEntryDescriptor::
 nsInputStreamWrapper::IsNonBlocking(bool *result)
 {
     // cache streams will never return NS_BASE_STREAM_WOULD_BLOCK
     *result = false;
     return NS_OK;
 }
 /******************************************************************************
  * nsDecompressInputStreamWrapper - an input stream wrapper that decompresses
  ******************************************************************************/
 NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper)
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::Release()
 {
     // Holding a reference to descriptor ensures that cache service won't go
     // away. Do not grab cache service lock if there is no descriptor.
     nsRefPtr<nsCacheEntryDescriptor> desc;
     {
         mozilla::MutexAutoLock lock(mLock);
         desc = mDescriptor;
     }
     if (desc)
         nsCacheService::Lock(LOCK_TELEM(
                              NSDECOMPRESSINPUTSTREAMWRAPPER_RELEASE));
     nsrefcnt count;
     NS_PRECONDITION(0 != mRefCnt, "dup release");
     count = --mRefCnt;
     NS_LOG_RELEASE(this, count,
                    "nsCacheEntryDescriptor::nsDecompressInputStreamWrapper");
     if (0 == count) {
         // don't use desc here since mDescriptor might be already nulled out
         if (mDescriptor) {
             NS_ASSERTION(mDescriptor->mInputWrappers.IndexOf(this) != -1,
                          "Wrapper not found in array!");
             mDescriptor->mInputWrappers.RemoveElement(this);
         }
         if (desc)
             nsCacheService::Unlock();
         mRefCnt = 1;
         delete (this);
         return 0;
     }
     if (desc)
         nsCacheService::Unlock();
     return count;
 }
 NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper)
   NS_INTERFACE_MAP_ENTRY(nsIInputStream)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END_THREADSAFE
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsDecompressInputStreamWrapper::Read(char *    buf,
                                      uint32_t  count,
                                      uint32_t *countRead)
 {
     mozilla::MutexAutoLock lock(mLock);
     int zerr = Z_OK;
     nsresult rv = NS_OK;
     if (!mStreamInitialized) {
         rv = InitZstream();
         if (NS_FAILED(rv)) {
             return rv;
         }
     }
     mZstream.next_out = (Bytef*)buf;
     mZstream.avail_out = count;
     if (mReadBufferLen < count) {
         // Allocate a buffer for reading from the input stream. This will
         // determine the max number of compressed bytes read from the
         // input stream at one time. Making the buffer size proportional
         // to the request size is not necessary, but helps minimize the
         // number of read requests to the input stream.
         uint32_t newBufLen = std::max(count, (uint32_t)kMinDecompressReadBufLen);
         unsigned char* newBuf;
         newBuf = (unsigned char*)nsMemory::Realloc(mReadBuffer,
             newBufLen);
         if (newBuf) {
             mReadBuffer = newBuf;
             mReadBufferLen = newBufLen;
         }
         if (!mReadBuffer) {
             mReadBufferLen = 0;
             return NS_ERROR_OUT_OF_MEMORY;
         }
     }
     // read and inflate data until the output buffer is full, or
     // there is no more data to read
     while (NS_SUCCEEDED(rv) &&
            zerr == Z_OK &&
            mZstream.avail_out > 0 &&
            count > 0) {
         if (mZstream.avail_in == 0) {
             rv = nsInputStreamWrapper::Read_Locked((char*)mReadBuffer,
                                                    mReadBufferLen,
                                                    &mZstream.avail_in);
             if (NS_FAILED(rv) || !mZstream.avail_in) {
                 break;
             }
             mZstream.next_in = mReadBuffer;
         }
         zerr = inflate(&mZstream, Z_NO_FLUSH);
         if (zerr == Z_STREAM_END) {
             // The compressed data may have been stored in multiple
             // chunks/streams. To allow for this case, re-initialize
             // the inflate stream and continue decompressing from
             // the next byte.
             Bytef * saveNextIn = mZstream.next_in;
             unsigned int saveAvailIn = mZstream.avail_in;
             Bytef * saveNextOut = mZstream.next_out;
             unsigned int saveAvailOut = mZstream.avail_out;
             inflateReset(&mZstream);
             mZstream.next_in = saveNextIn;
             mZstream.avail_in = saveAvailIn;
             mZstream.next_out = saveNextOut;
             mZstream.avail_out = saveAvailOut;
             zerr = Z_OK;
         } else if (zerr != Z_OK) {
             rv = NS_ERROR_INVALID_CONTENT_ENCODING;
         }
     }
     if (NS_SUCCEEDED(rv)) {
         *countRead = count - mZstream.avail_out;
     }
     return rv;
 }
 nsresult nsCacheEntryDescriptor::
 nsDecompressInputStreamWrapper::Close()
 {
     mozilla::MutexAutoLock lock(mLock);
     if (!mDescriptor)
         return NS_ERROR_NOT_AVAILABLE;
     EndZstream();
     if (mReadBuffer) {
         nsMemory::Free(mReadBuffer);
         mReadBuffer = 0;
         mReadBufferLen = 0;
     }
     return nsInputStreamWrapper::Close_Locked();
 }
 nsresult nsCacheEntryDescriptor::
 nsDecompressInputStreamWrapper::InitZstream()
 {
     if (!mDescriptor)
         return NS_ERROR_NOT_AVAILABLE;
     if (mStreamEnded)
         return NS_ERROR_FAILURE;
     // Initialize zlib inflate stream
     mZstream.zalloc = Z_NULL;
     mZstream.zfree = Z_NULL;
     mZstream.opaque = Z_NULL;
     mZstream.next_out = Z_NULL;
     mZstream.avail_out = 0;
     mZstream.next_in = Z_NULL;
     mZstream.avail_in = 0;
     if (inflateInit(&mZstream) != Z_OK) {
         return NS_ERROR_FAILURE;
     }
     mStreamInitialized = true;
     return NS_OK;
 }
 nsresult nsCacheEntryDescriptor::
 nsDecompressInputStreamWrapper::EndZstream()
 {
     if (mStreamInitialized && !mStreamEnded) {
         inflateEnd(&mZstream);
         mStreamInitialized = false;
         mStreamEnded = true;
     }
     return NS_OK;
 }
 /******************************************************************************
  * nsOutputStreamWrapper - a wrapper for nsIOutputstream to track the amount of
  *                         data written to a cache entry.
  *                       - also keeps the cache entry open while referenced.
  ******************************************************************************/
 NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsOutputStreamWrapper)
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsCacheEntryDescriptor::nsOutputStreamWrapper::Release()
 {
     // Holding a reference to descriptor ensures that cache service won't go
     // away. Do not grab cache service lock if there is no descriptor.
     nsRefPtr<nsCacheEntryDescriptor> desc;
     {
         mozilla::MutexAutoLock lock(mLock);
         desc = mDescriptor;
     }
     if (desc)
         nsCacheService::Lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_RELEASE));
     nsrefcnt count;
     NS_PRECONDITION(0 != mRefCnt, "dup release");
     count = --mRefCnt;
     NS_LOG_RELEASE(this, count,
                    "nsCacheEntryDescriptor::nsOutputStreamWrapper");
     if (0 == count) {
         // don't use desc here since mDescriptor might be already nulled out
         if (mDescriptor)
             mDescriptor->mOutputWrapper = nullptr;
         if (desc)
             nsCacheService::Unlock();
         mRefCnt = 1;
         delete (this);
         return 0;
     }
     if (desc)
         nsCacheService::Unlock();
     return count;
 }
 NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsOutputStreamWrapper)
   NS_INTERFACE_MAP_ENTRY(nsIOutputStream)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END_THREADSAFE
 nsresult nsCacheEntryDescriptor::
 nsOutputStreamWrapper::LazyInit()
 {
     // Check if we have the descriptor. If not we can't even grab the cache
     // lock since it is not ensured that the cache service still exists.
     if (!mDescriptor)
         return NS_ERROR_NOT_AVAILABLE;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_LAZYINIT));
     nsCacheAccessMode mode;
     nsresult rv = mDescriptor->GetAccessGranted(&mode);
     if (NS_FAILED(rv)) return rv;
     NS_ENSURE_TRUE(mode & nsICache::ACCESS_WRITE, NS_ERROR_UNEXPECTED);
     nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
     if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
     NS_ASSERTION(mOutput == nullptr, "mOutput set in LazyInit");
     nsCOMPtr<nsIOutputStream> stream;
     rv = nsCacheService::OpenOutputStreamForEntry(cacheEntry, mode, mStartOffset,
                                                   getter_AddRefs(stream));
     if (NS_FAILED(rv))
         return rv;
     nsCacheDevice* device = cacheEntry->CacheDevice();
     if (device) {
         // the entry has been truncated to mStartOffset bytes, inform device
         int32_t size = cacheEntry->DataSize();
         rv = device->OnDataSizeChange(cacheEntry, mStartOffset - size);
         if (NS_SUCCEEDED(rv))
             cacheEntry->SetDataSize(mStartOffset);
     } else {
         rv = NS_ERROR_NOT_AVAILABLE;
     }
     // If anything above failed, clean up internal state and get out of here
     // (see bug #654926)...
     if (NS_FAILED(rv)) {
         nsCacheService::ReleaseObject_Locked(stream.forget().take());
         mDescriptor->mOutputWrapper = nullptr;
         nsCacheService::ReleaseObject_Locked(mDescriptor);
         mDescriptor = nullptr;
         mInitialized = false;
         return rv;
     }
     mOutput = stream;
     mInitialized = true;
     return NS_OK;
 }
 nsresult nsCacheEntryDescriptor::
 nsOutputStreamWrapper::EnsureInit()
 {
     if (mInitialized) {
         NS_ASSERTION(mDescriptor, "Bad state");
         return NS_OK;
     }
     return LazyInit();
 }
 nsresult nsCacheEntryDescriptor::
 nsOutputStreamWrapper::OnWrite(uint32_t count)
 {
     if (count > INT32_MAX)  return NS_ERROR_UNEXPECTED;
     return mDescriptor->RequestDataSizeChange((int32_t)count);
 }
 void nsCacheEntryDescriptor::
 nsOutputStreamWrapper::CloseInternal()
 {
     mLock.AssertCurrentThreadOwns();
     if (!mDescriptor) {
         NS_ASSERTION(!mInitialized, "Bad state");
         NS_ASSERTION(!mOutput, "Bad state");
         return;
     }
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_CLOSEINTERNAL));
     if (mDescriptor) {
         mDescriptor->mOutputWrapper = nullptr;
         nsCacheService::ReleaseObject_Locked(mDescriptor);
         mDescriptor = nullptr;
     }
     mInitialized = false;
     mOutput = nullptr;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsOutputStreamWrapper::Close()
 {
     mozilla::MutexAutoLock lock(mLock);
     return Close_Locked();
 }
 nsresult nsCacheEntryDescriptor::
 nsOutputStreamWrapper::Close_Locked()
 {
     nsresult rv = EnsureInit();
     if (NS_SUCCEEDED(rv)) {
         rv = mOutput->Close();
     } else {
         NS_ASSERTION(!mOutput,
                      "Shouldn't have mOutput when EnsureInit() failed");
     }
     // Call CloseInternal() even when EnsureInit() failed, e.g. in case we are
     // closing streams with nsCacheService::CloseAllStream()
     CloseInternal();
     return rv;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsOutputStreamWrapper::Flush()
 {
     mozilla::MutexAutoLock lock(mLock);
     nsresult rv = EnsureInit();
     if (NS_FAILED(rv)) return rv;
     return mOutput->Flush();
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsOutputStreamWrapper::Write(const char * buf,
                              uint32_t     count,
                              uint32_t *   result)
 {
     mozilla::MutexAutoLock lock(mLock);
     return Write_Locked(buf, count, result);
 }
 nsresult nsCacheEntryDescriptor::
 nsOutputStreamWrapper::Write_Locked(const char * buf,
                                     uint32_t count,
                                     uint32_t * result)
 {
     nsresult rv = EnsureInit();
     if (NS_FAILED(rv)) return rv;
     rv = OnWrite(count);
     if (NS_FAILED(rv)) return rv;
     return mOutput->Write(buf, count, result);
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsOutputStreamWrapper::WriteFrom(nsIInputStream * inStr,
                                  uint32_t         count,
                                  uint32_t *       result)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsOutputStreamWrapper::WriteSegments(nsReadSegmentFun  reader,
                                      void *            closure,
                                      uint32_t          count,
                                      uint32_t *        result)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsOutputStreamWrapper::IsNonBlocking(bool *result)
 {
     // cache streams will never return NS_BASE_STREAM_WOULD_BLOCK
     *result = false;
     return NS_OK;
 }
 /******************************************************************************
  * nsCompressOutputStreamWrapper - an output stream wrapper that compresses
  *   data before it is written
  ******************************************************************************/
 NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper)
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::Release()
 {
     // Holding a reference to descriptor ensures that cache service won't go
     // away. Do not grab cache service lock if there is no descriptor.
     nsRefPtr<nsCacheEntryDescriptor> desc;
     {
         mozilla::MutexAutoLock lock(mLock);
         desc = mDescriptor;
     }
     if (desc)
         nsCacheService::Lock(LOCK_TELEM(NSCOMPRESSOUTPUTSTREAMWRAPPER_RELEASE));
     nsrefcnt count;
     NS_PRECONDITION(0 != mRefCnt, "dup release");
     count = --mRefCnt;
     NS_LOG_RELEASE(this, count,
                    "nsCacheEntryDescriptor::nsCompressOutputStreamWrapper");
     if (0 == count) {
         // don't use desc here since mDescriptor might be already nulled out
         if (mDescriptor)
             mDescriptor->mOutputWrapper = nullptr;
         if (desc)
             nsCacheService::Unlock();
         mRefCnt = 1;
         delete (this);
         return 0;
     }
     if (desc)
         nsCacheService::Unlock();
     return count;
 }
 NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper)
   NS_INTERFACE_MAP_ENTRY(nsIOutputStream)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END_THREADSAFE
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsCompressOutputStreamWrapper::Write(const char * buf,
                                      uint32_t     count,
                                      uint32_t *   result)
 {
     mozilla::MutexAutoLock lock(mLock);
     int zerr = Z_OK;
     nsresult rv = NS_OK;
     if (!mStreamInitialized) {
         rv = InitZstream();
         if (NS_FAILED(rv)) {
             return rv;
         }
     }
     if (!mWriteBuffer) {
         // Once allocated, this buffer is referenced by the zlib stream and
         // cannot be grown. We use 2x(initial write request) to approximate
         // a stream buffer size proportional to request buffers.
         mWriteBufferLen = std::max(count*2, (uint32_t)kMinCompressWriteBufLen);
         mWriteBuffer = (unsigned char*)nsMemory::Alloc(mWriteBufferLen);
         if (!mWriteBuffer) {
             mWriteBufferLen = 0;
             return NS_ERROR_OUT_OF_MEMORY;
         }
         mZstream.next_out = mWriteBuffer;
         mZstream.avail_out = mWriteBufferLen;
     }
     // Compress (deflate) the requested buffer. Keep going
     // until the entire buffer has been deflated.
     mZstream.avail_in = count;
     mZstream.next_in = (Bytef*)buf;
     while (mZstream.avail_in > 0) {
         zerr = deflate(&mZstream, Z_NO_FLUSH);
         if (zerr == Z_STREAM_ERROR) {
             deflateEnd(&mZstream);
             mStreamEnded = true;
             mStreamInitialized = false;
             return NS_ERROR_FAILURE;
         }
         // Note: Z_BUF_ERROR is non-fatal and sometimes expected here.
         // If the compression stream output buffer is filled, write
         // it out to the underlying stream wrapper.
         if (mZstream.avail_out == 0) {
             rv = WriteBuffer();
             if (NS_FAILED(rv)) {
                 deflateEnd(&mZstream);
                 mStreamEnded = true;
                 mStreamInitialized = false;
                 return rv;
             }
         }
     }
     *result = count;
     mUncompressedCount += *result;
     return NS_OK;
 }
 NS_IMETHODIMP nsCacheEntryDescriptor::
 nsCompressOutputStreamWrapper::Close()
 {
     mozilla::MutexAutoLock lock(mLock);
     if (!mDescriptor)
         return NS_ERROR_NOT_AVAILABLE;
     nsresult retval = NS_OK;
     nsresult rv;
     int zerr = 0;
     if (mStreamInitialized) {
         // complete compression of any data remaining in the zlib stream
         do {
             zerr = deflate(&mZstream, Z_FINISH);
             rv = WriteBuffer();
             if (NS_FAILED(rv))
                 retval = rv;
         } while (zerr == Z_OK && rv == NS_OK);
         deflateEnd(&mZstream);
         mStreamInitialized = false;
     }
     // Do not allow to initialize stream after calling Close().
     mStreamEnded = true;
     if (mDescriptor->CacheEntry()) {
         nsAutoCString uncompressedLenStr;
         rv = mDescriptor->GetMetaDataElement("uncompressed-len",
                                              getter_Copies(uncompressedLenStr));
         if (NS_SUCCEEDED(rv)) {
             int32_t oldCount = uncompressedLenStr.ToInteger(&rv);
             if (NS_SUCCEEDED(rv)) {
                 mUncompressedCount += oldCount;
             }
         }
         uncompressedLenStr.Adopt(0);
         uncompressedLenStr.AppendInt(mUncompressedCount);
         rv = mDescriptor->SetMetaDataElement("uncompressed-len",
             uncompressedLenStr.get());
         if (NS_FAILED(rv))
             retval = rv;
     }
     if (mWriteBuffer) {
         nsMemory::Free(mWriteBuffer);
         mWriteBuffer = 0;
         mWriteBufferLen = 0;
     }
     rv = nsOutputStreamWrapper::Close_Locked();
     if (NS_FAILED(rv))
         retval = rv;
     return retval;
 }
 nsresult nsCacheEntryDescriptor::
 nsCompressOutputStreamWrapper::InitZstream()
 {
     if (!mDescriptor)
         return NS_ERROR_NOT_AVAILABLE;
     if (mStreamEnded)
         return NS_ERROR_FAILURE;
     // Determine compression level: Aggressive compression
     // may impact performance on mobile devices, while a
     // lower compression level still provides substantial
     // space savings for many text streams.
     int32_t compressionLevel = nsCacheService::CacheCompressionLevel();
     // Initialize zlib deflate stream
     mZstream.zalloc = Z_NULL;
     mZstream.zfree = Z_NULL;
     mZstream.opaque = Z_NULL;
     if (deflateInit2(&mZstream, compressionLevel, Z_DEFLATED,
                      MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
         return NS_ERROR_FAILURE;
     }
     mZstream.next_in = Z_NULL;
     mZstream.avail_in = 0;
     mStreamInitialized = true;
     return NS_OK;
 }
 nsresult nsCacheEntryDescriptor::
 nsCompressOutputStreamWrapper::WriteBuffer()
 {
     uint32_t bytesToWrite = mWriteBufferLen - mZstream.avail_out;
     uint32_t result = 0;
     nsresult rv = nsCacheEntryDescriptor::nsOutputStreamWrapper::Write_Locked(
         (const char *)mWriteBuffer, bytesToWrite, &result);
     mZstream.next_out = mWriteBuffer;
     mZstream.avail_out = mWriteBufferLen;
     return rv;
 }

The Tor Browser / annotate

netwerk/cache/nsCacheEntryDescriptor.cpp@6474c204b198 (annotated)

netwerk/cache/nsCacheEntryDescriptor.cpp