tor-browser

CacheEntry.h (22200B)

---

/* 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/. */

#ifndef CacheEntry__h__
#define CacheEntry__h__

#include "mozilla/LinkedList.h"
#include "nsICacheEntry.h"
#include "CacheFile.h"

#include "nsIRunnable.h"
#include "nsIOutputStream.h"
#include "nsICacheEntryOpenCallback.h"
#include "nsICacheEntryDoomCallback.h"
#include "nsITransportSecurityInfo.h"

#include "nsCOMPtr.h"
#include "nsRefPtrHashtable.h"
#include "nsHashKeys.h"
#include "nsString.h"
#include "nsCOMArray.h"
#include "nsThreadUtils.h"
#include "mozilla/Mutex.h"
#include "mozilla/TimeStamp.h"
#include "Dictionary.h"

static inline uint32_t PRTimeToSeconds(PRTime t_usec) {
 return uint32_t(t_usec / PR_USEC_PER_SEC);
}

#define NowInSeconds() PRTimeToSeconds(PR_Now())

class nsIOutputStream;
class nsIURI;
class nsIThread;

namespace mozilla {
namespace net {

class CacheStorageService;
class CacheStorage;
class CacheOutputCloseListener;
class CacheEntryHandle;

class CacheEntry final : public nsIRunnable,
                        public CacheFileListener,
                        // Used by CacheStorageService::MemoryPool
                        public LinkedListElement<RefPtr<CacheEntry>> {
public:
 NS_DECL_THREADSAFE_ISUPPORTS
 NS_DECL_NSIRUNNABLE

 static uint64_t GetNextId();

 CacheEntry(const nsACString& aStorageID, const nsACString& aURI,
            const nsACString& aEnhanceID, bool aUseDisk, bool aSkipSizeCheck,
            bool aPin);

 void AsyncOpen(nsICacheEntryOpenCallback* aCallback, uint32_t aFlags);

 CacheEntryHandle* NewHandle();
 // For a new and recreated entry w/o a callback, we need to wrap it
 // with a handle to detect writing consumer is gone.
 CacheEntryHandle* NewWriteHandle();

 // Forwarded to from CacheEntryHandle : nsICacheEntry
 nsresult GetKey(nsACString& aKey);
 nsresult GetCacheEntryId(uint64_t* aCacheEntryId);
 nsresult GetPersistent(bool* aPersistToDisk);
 nsresult GetFetchCount(uint32_t* aFetchCount);
 nsresult GetLastFetched(uint32_t* aLastFetched);
 nsresult GetLastModified(uint32_t* aLastModified);
 nsresult GetExpirationTime(uint32_t* aExpirationTime);
 nsresult SetExpirationTime(uint32_t expirationTime);
 nsresult GetOnStartTime(uint64_t* aTime);
 nsresult GetOnStopTime(uint64_t* aTime);
 nsresult GetReadyOrRevalidating(bool* aReady);
 nsresult SetNetworkTimes(uint64_t onStartTime, uint64_t onStopTime);
 nsresult SetContentType(uint8_t aContentType);
 nsresult ForceValidFor(uint32_t aSecondsToTheFuture);
 nsresult GetIsForcedValid(bool* aIsForcedValid);
 nsresult MarkForcedValidUse();
 nsresult OpenInputStream(int64_t offset, nsIInputStream** _retval);
 nsresult OpenOutputStream(int64_t offset, int64_t predictedSize,
                           nsIOutputStream** _retval);
 nsresult GetSecurityInfo(nsITransportSecurityInfo** aSecurityInfo);
 nsresult SetSecurityInfo(nsITransportSecurityInfo* aSecurityInfo);
 nsresult GetStorageDataSize(uint32_t* aStorageDataSize);
 nsresult AsyncDoom(nsICacheEntryDoomCallback* aCallback);
 nsresult GetMetaDataElement(const char* key, char** aRetval);
 nsresult SetMetaDataElement(const char* key, const char* value);
 nsresult GetIsEmpty(bool* aEmpty);
 nsresult VisitMetaData(nsICacheEntryMetaDataVisitor* visitor);
 nsresult MetaDataReady(void);
 nsresult SetValid(void);
 nsresult GetDiskStorageSizeInKB(uint32_t* aDiskStorageSizeInKB);
 nsresult Recreate(bool aMemoryOnly, nsICacheEntry** _retval);
 nsresult GetDataSize(int64_t* aDataSize);
 nsresult GetAltDataSize(int64_t* aDataSize);
 nsresult GetAltDataType(nsACString& aAltDataType);
 nsresult OpenAlternativeOutputStream(const nsACString& type,
                                      int64_t predictedSize,
                                      nsIAsyncOutputStream** _retval);
 nsresult OpenAlternativeInputStream(const nsACString& type,
                                     nsIInputStream** _retval);
 nsresult GetLoadContextInfo(nsILoadContextInfo** aInfo);

 nsresult SetDictionary(DictionaryCacheEntry* aDict);

public:
 uint32_t GetMetadataMemoryConsumption();
 nsCString const& GetStorageID() const { return mStorageID; }
 nsCString const& GetEnhanceID() const { return mEnhanceID; }
 nsCString const& GetURI() const { return mURI; }
 // Accessible at any time
 bool IsUsingDisk() const { return mUseDisk; }
 bool IsReferenced() const MOZ_NO_THREAD_SAFETY_ANALYSIS;
 bool IsFileDoomed();
 bool IsDoomed() const { return mIsDoomed; }
 bool IsPinned() const { return mPinned; }

 // Mark entry to allow bypassing writer lock for new listeners
 void SetBypassWriterLock(bool aBypass);
 bool ShouldBypassWriterLock() const MOZ_REQUIRES(mLock) {
   return mBypassWriterLock;
 }

 // Methods for entry management (eviction from memory),
 // called only on the management thread.

 // TODO make these inline
 double GetFrecency() const;
 uint32_t GetExpirationTime() const;
 uint32_t UseCount() const { return mUseCount; }

 bool IsRegistered() const;
 bool CanRegister() const;
 void SetRegistered(bool aRegistered);

 TimeStamp const& LoadStart() const { return mLoadStart; }

 enum EPurge {
   PURGE_DATA_ONLY_DISK_BACKED,
   PURGE_WHOLE_ONLY_DISK_BACKED,
   PURGE_WHOLE,
 };

 bool DeferOrBypassRemovalOnPinStatus(bool aPinned);
 bool Purge(uint32_t aWhat);
 void PurgeAndDoom();
 void DoomAlreadyRemoved();

 nsresult HashingKeyWithStorage(nsACString& aResult) const;
 nsresult HashingKey(nsACString& aResult) const;

 static nsresult HashingKey(const nsACString& aStorageID,
                            const nsACString& aEnhanceID, nsIURI* aURI,
                            nsACString& aResult);

 static nsresult HashingKey(const nsACString& aStorageID,
                            const nsACString& aEnhanceID,
                            const nsACString& aURISpec, nsACString& aResult);

 // Accessed only on the service management thread
 double mFrecency{0};
 ::mozilla::Atomic<uint32_t, ::mozilla::Relaxed> mSortingExpirationTime{
     uint32_t(-1)};

 // Memory reporting
 size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf);
 size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);

private:
 virtual ~CacheEntry();

 // CacheFileListener
 NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew) override;
 NS_IMETHOD OnFileDoomed(nsresult aResult) override;

 // Keep the service alive during life-time of an entry
 RefPtr<CacheStorageService> mService;

 // We must monitor when a cache entry whose consumer is responsible
 // for writing it the first time gets released.  We must then invoke
 // waiting callbacks to not break the chain.
 class Callback {
  public:
   Callback(CacheEntry* aEntry, nsICacheEntryOpenCallback* aCallback,
            bool aReadOnly, bool aCheckOnAnyThread, bool aSecret);
   // Special constructor for Callback objects added to the chain
   // just to ensure proper defer dooming (recreation) of this entry.
   Callback(CacheEntry* aEntry, bool aDoomWhenFoundInPinStatus);
   Callback(Callback const& aThat);
   ~Callback();

   // Called when this callback record changes it's owning entry,
   // mainly during recreation.
   void ExchangeEntry(CacheEntry* aEntry) MOZ_REQUIRES(aEntry->mLock);

   // Returns true when an entry is about to be "defer" doomed and this is
   // a "defer" callback.  The caller must hold a lock (this entry is in the
   // caller's mCallback array)
   bool DeferDoom(bool* aDoom) const;

   // We are raising reference count here to take into account the pending
   // callback (that virtually holds a ref to this entry before it gets
   // it's pointer).
   RefPtr<CacheEntry> mEntry;
   nsCOMPtr<nsICacheEntryOpenCallback> mCallback;
   nsCOMPtr<nsIEventTarget> mTarget;
   bool mReadOnly : 1;
   bool mRevalidating : 1;
   bool mCheckOnAnyThread : 1;
   bool mRecheckAfterWrite : 1;
   bool mNotWanted : 1;
   bool mSecret : 1;

   // These are set only for the defer-doomer Callback instance inserted
   // to the callback chain.  When any of these is set and also any of
   // the corressponding flags on the entry is set, this callback will
   // indicate (via DeferDoom()) the entry have to be recreated/doomed.
   bool mDoomWhenFoundPinned : 1;
   bool mDoomWhenFoundNonPinned : 1;

   nsresult OnCheckThread(bool* aOnCheckThread) const;
   nsresult OnAvailThread(bool* aOnAvailThread) const;
 };

 // Since OnCacheEntryAvailable must be invoked on the main thread
 // we need a runnable for it...
 class AvailableCallbackRunnable : public Runnable {
  public:
   AvailableCallbackRunnable(CacheEntry* aEntry, Callback const& aCallback)
       : Runnable("CacheEntry::AvailableCallbackRunnable"),
         mEntry(aEntry),
         mCallback(aCallback) {}

  private:
   NS_IMETHOD Run() override {
     mEntry->InvokeAvailableCallback(mCallback);
     return NS_OK;
   }

   RefPtr<CacheEntry> mEntry;
   Callback mCallback;
 };

 // Since OnCacheEntryDoomed must be invoked on the main thread
 // we need a runnable for it...
 class DoomCallbackRunnable : public Runnable {
  public:
   DoomCallbackRunnable(CacheEntry* aEntry, nsresult aRv)
       : Runnable("net::CacheEntry::DoomCallbackRunnable"),
         mEntry(aEntry),
         mRv(aRv) {}

  private:
   NS_IMETHOD Run() override {
     nsCOMPtr<nsICacheEntryDoomCallback> callback;
     {
       mozilla::MutexAutoLock lock(mEntry->mLock);
       mEntry->mDoomCallback.swap(callback);
     }

     if (callback) callback->OnCacheEntryDoomed(mRv);
     return NS_OK;
   }

   RefPtr<CacheEntry> mEntry;
   nsresult mRv;
 };

 // Starts the load or just invokes the callback, bypasses (when required)
 // if busy.  Returns true on job done, false on bypass.
 bool Open(Callback& aCallback, bool aTruncate, bool aPriority,
           bool aBypassIfBusy);
 // Loads from disk asynchronously
 bool Load(bool aTruncate, bool aPriority);

 void RememberCallback(Callback& aCallback) MOZ_REQUIRES(mLock);
 void InvokeCallbacksLock();
 void InvokeCallbacks();
 bool InvokeCallbacks(bool aReadOnly);
 bool InvokeCallback(Callback& aCallback);
 void InvokeAvailableCallback(Callback const& aCallback);
 void OnFetched(Callback const& aCallback);

 nsresult OpenOutputStreamInternal(int64_t offset, nsIOutputStream** _retval);
 nsresult OpenInputStreamInternal(int64_t offset, const char* aAltDataType,
                                  nsIInputStream** _retval);

 void OnHandleClosed(CacheEntryHandle const* aHandle);

private:
 friend class CacheEntryHandle;
 // Increment/decrements the number of handles keeping this entry.
 void AddHandleRef() MOZ_REQUIRES(mLock) { ++mHandlesCount; }
 void ReleaseHandleRef() MOZ_REQUIRES(mLock) { --mHandlesCount; }
 // Current number of handles keeping this entry.
 uint32_t HandlesCount() const MOZ_REQUIRES(mLock) { return mHandlesCount; }

private:
 friend class CacheOutputCloseListener;
 void OnOutputClosed();

private:
 // Schedules a background operation on the management thread.
 // When executed on the management thread directly, the operation(s)
 // is (are) executed immediately.
 void BackgroundOp(uint32_t aOperation, bool aForceAsync = false);
 void StoreFrecency(double aFrecency);

 // Called only from DoomAlreadyRemoved()
 void DoomFile() MOZ_REQUIRES(mLock);
 // When this entry is doomed the first time, this method removes
 // any force-valid timing info for this entry.
 void RemoveForcedValidity();

 already_AddRefed<CacheEntryHandle> ReopenTruncated(
     bool aMemoryOnly, nsICacheEntryOpenCallback* aCallback);
 void TransferCallbacks(CacheEntry& aFromEntry);

 mozilla::Mutex mLock{"CacheEntry"};

 // Reflects the number of existing handles for this entry
 ::mozilla::ThreadSafeAutoRefCnt mHandlesCount MOZ_GUARDED_BY(mLock);

 nsTArray<Callback> mCallbacks MOZ_GUARDED_BY(mLock);
 nsCOMPtr<nsICacheEntryDoomCallback> mDoomCallback;

 // Set in CacheEntry::Load(), only - shouldn't need to be under lock
 // XXX FIX?  is this correct?
 RefPtr<CacheFile> mFile;

 // Using ReleaseAcquire since we only control access to mFile with this.
 // When mFileStatus is read and found success it is ensured there is mFile and
 // that it is after a successful call to Init().
 Atomic<nsresult, ReleaseAcquire> mFileStatus{NS_ERROR_NOT_INITIALIZED};
 // Set in constructor
 nsCString const mURI;
 nsCString const mEnhanceID;
 nsCString const mStorageID;

 // mUseDisk, mSkipSizeCheck, mIsDoomed are plain "bool", not "bool:1",
 // so as to avoid bitfield races with the byte containing
 // mSecurityInfoLoaded et al.  See bug 1278524.
 //
 // Whether it's allowed to persist the data to disk
 bool const mUseDisk;
 // Whether it should skip max size check.
 bool const mSkipSizeCheck;
 // Set when entry is doomed with AsyncDoom() or DoomAlreadyRemoved().
 Atomic<bool, Relaxed> mIsDoomed{false};
 // The indication of pinning this entry was open with
 Atomic<bool, Relaxed> mPinned;

 // Following flags are all synchronized with the cache entry lock.

 // Whether security info has already been looked up in metadata.
 bool mSecurityInfoLoaded : 1 MOZ_GUARDED_BY(mLock);
 // Prevents any callback invocation
 bool mPreventCallbacks : 1 MOZ_GUARDED_BY(mLock);
 // true: after load and an existing file, or after output stream has been
 //       opened.
 //       note - when opening an input stream, and this flag is false, output
 //       stream is open along ; this makes input streams on new entries
 //       behave correctly when EOF is reached (WOULD_BLOCK is returned).
 // false: after load and a new file, or dropped to back to false when a
 //        writer fails to open an output stream.
 bool mHasData : 1 MOZ_GUARDED_BY(mLock);
 // Whether the pinning state of the entry is known (equals to the actual state
 // of the cache file)
 bool mPinningKnown : 1 MOZ_GUARDED_BY(mLock);
 // Whether to bypass writer lock for new listeners (when writer is suspended)
 bool mBypassWriterLock : 1 MOZ_GUARDED_BY(mLock);

 static char const* StateString(uint32_t aState);

 enum EState {       // transiting to:
   NOTLOADED = 0,    // -> LOADING | EMPTY
   LOADING = 1,      // -> EMPTY | READY
   EMPTY = 2,        // -> WRITING
   WRITING = 3,      // -> EMPTY | READY
   READY = 4,        // -> REVALIDATING
   REVALIDATING = 5  // -> READY
 };

 // State of this entry.
 EState mState MOZ_GUARDED_BY(mLock){NOTLOADED};

 enum ERegistration {
   NEVERREGISTERED = 0,  // The entry has never been registered
   REGISTERED = 1,       // The entry is stored in the memory pool index
   DEREGISTERED = 2      // The entry has been removed from the pool
 };

 // Accessed only on the management thread.  Records the state of registration
 // this entry in the memory pool intermediate cache.
 ERegistration mRegistration{NEVERREGISTERED};

 // If a new (empty) entry is requested to open an input stream before
 // output stream has been opened, we must open output stream internally
 // on CacheFile and hold until writer releases the entry or opens the output
 // stream for read (then we trade him mOutputStream).
 nsCOMPtr<nsIOutputStream> mOutputStream MOZ_GUARDED_BY(mLock);

 // Weak reference to the current writter.  There can be more then one
 // writer at a time and OnHandleClosed() must be processed only for the
 // current one.
 CacheEntryHandle* mWriter MOZ_GUARDED_BY(mLock){nullptr};

 // Background thread scheduled operation.  Set (under the lock) one
 // of this flags to tell the background thread what to do.
 class Ops {
  public:
   static uint32_t const REGISTER = 1 << 0;
   static uint32_t const FRECENCYUPDATE = 1 << 1;
   static uint32_t const CALLBACKS = 1 << 2;
   static uint32_t const UNREGISTER = 1 << 3;

   Ops() = default;
   uint32_t Grab() {
     uint32_t flags = mFlags;
     mFlags = 0;
     return flags;
   }
   bool Set(uint32_t aFlags) {
     if (mFlags & aFlags) return false;
     mFlags |= aFlags;
     return true;
   }

  private:
   uint32_t mFlags{0};
 } mBackgroundOperations;

 nsCOMPtr<nsITransportSecurityInfo> mSecurityInfo;
 mozilla::TimeStamp mLoadStart;
 uint32_t mUseCount{0};

 RefPtr<DictionaryCacheEntry> mDict;

 const uint64_t mCacheEntryId;
};

class CacheEntryHandle final : public nsICacheEntry {
public:
 explicit CacheEntryHandle(CacheEntry* aEntry);
 CacheEntry* Entry() const { return mEntry; }

 NS_DECL_THREADSAFE_ISUPPORTS

 // Default implementation is simply safely forwarded.
 NS_IMETHOD GetKey(nsACString& aKey) override { return mEntry->GetKey(aKey); }
 NS_IMETHOD GetCacheEntryId(uint64_t* aCacheEntryId) override {
   return mEntry->GetCacheEntryId(aCacheEntryId);
 }
 NS_IMETHOD GetPersistent(bool* aPersistent) override {
   return mEntry->GetPersistent(aPersistent);
 }
 NS_IMETHOD GetFetchCount(uint32_t* aFetchCount) override {
   return mEntry->GetFetchCount(aFetchCount);
 }
 NS_IMETHOD GetLastFetched(uint32_t* aLastFetched) override {
   return mEntry->GetLastFetched(aLastFetched);
 }
 NS_IMETHOD GetLastModified(uint32_t* aLastModified) override {
   return mEntry->GetLastModified(aLastModified);
 }
 NS_IMETHOD GetExpirationTime(uint32_t* aExpirationTime) override {
   return mEntry->GetExpirationTime(aExpirationTime);
 }
 NS_IMETHOD SetExpirationTime(uint32_t expirationTime) override {
   return mEntry->SetExpirationTime(expirationTime);
 }
 NS_IMETHOD GetOnStartTime(uint64_t* aOnStartTime) override {
   return mEntry->GetOnStartTime(aOnStartTime);
 }
 NS_IMETHOD GetOnStopTime(uint64_t* aOnStopTime) override {
   return mEntry->GetOnStopTime(aOnStopTime);
 }
 NS_IMETHOD GetReadyOrRevalidating(bool* aReady) override {
   return mEntry->GetReadyOrRevalidating(aReady);
 }
 NS_IMETHOD SetNetworkTimes(uint64_t onStartTime,
                            uint64_t onStopTime) override {
   return mEntry->SetNetworkTimes(onStartTime, onStopTime);
 }
 NS_IMETHOD SetContentType(uint8_t contentType) override {
   return mEntry->SetContentType(contentType);
 }
 NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture) override {
   return mEntry->ForceValidFor(aSecondsToTheFuture);
 }
 NS_IMETHOD GetIsForcedValid(bool* aIsForcedValid) override {
   return mEntry->GetIsForcedValid(aIsForcedValid);
 }
 NS_IMETHOD MarkForcedValidUse() override {
   return mEntry->MarkForcedValidUse();
 }
 NS_IMETHOD OpenInputStream(int64_t offset,
                            nsIInputStream** _retval) override {
   return mEntry->OpenInputStream(offset, _retval);
 }
 NS_IMETHOD OpenOutputStream(int64_t offset, int64_t predictedSize,
                             nsIOutputStream** _retval) override {
   return mEntry->OpenOutputStream(offset, predictedSize, _retval);
 }
 NS_IMETHOD GetSecurityInfo(
     nsITransportSecurityInfo** aSecurityInfo) override {
   return mEntry->GetSecurityInfo(aSecurityInfo);
 }
 NS_IMETHOD SetSecurityInfo(nsITransportSecurityInfo* aSecurityInfo) override {
   return mEntry->SetSecurityInfo(aSecurityInfo);
 }
 NS_IMETHOD GetStorageDataSize(uint32_t* aStorageDataSize) override {
   return mEntry->GetStorageDataSize(aStorageDataSize);
 }
 NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener) override {
   return mEntry->AsyncDoom(listener);
 }
 NS_IMETHOD GetMetaDataElement(const char* key, char** _retval) override {
   return mEntry->GetMetaDataElement(key, _retval);
 }
 NS_IMETHOD SetMetaDataElement(const char* key, const char* value) override {
   return mEntry->SetMetaDataElement(key, value);
 }
 NS_IMETHOD GetIsEmpty(bool* empty) override {
   return mEntry->GetIsEmpty(empty);
 }
 NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor* visitor) override {
   return mEntry->VisitMetaData(visitor);
 }
 NS_IMETHOD MetaDataReady(void) override { return mEntry->MetaDataReady(); }
 NS_IMETHOD SetValid(void) override { return mEntry->SetValid(); }
 NS_IMETHOD GetDiskStorageSizeInKB(uint32_t* aDiskStorageSizeInKB) override {
   return mEntry->GetDiskStorageSizeInKB(aDiskStorageSizeInKB);
 }
 NS_IMETHOD Recreate(bool aMemoryOnly, nsICacheEntry** _retval) override {
   return mEntry->Recreate(aMemoryOnly, _retval);
 }
 NS_IMETHOD GetDataSize(int64_t* aDataSize) override {
   return mEntry->GetDataSize(aDataSize);
 }
 NS_IMETHOD GetAltDataSize(int64_t* aAltDataSize) override {
   return mEntry->GetAltDataSize(aAltDataSize);
 }
 NS_IMETHOD GetAltDataType(nsACString& aType) override {
   return mEntry->GetAltDataType(aType);
 }
 NS_IMETHOD OpenAlternativeOutputStream(
     const nsACString& type, int64_t predictedSize,
     nsIAsyncOutputStream** _retval) override {
   return mEntry->OpenAlternativeOutputStream(type, predictedSize, _retval);
 }
 NS_IMETHOD OpenAlternativeInputStream(const nsACString& type,
                                       nsIInputStream** _retval) override {
   return mEntry->OpenAlternativeInputStream(type, _retval);
 }
 NS_IMETHOD GetLoadContextInfo(
     nsILoadContextInfo** aLoadContextInfo) override {
   return mEntry->GetLoadContextInfo(aLoadContextInfo);
 }
 NS_IMETHOD SetDictionary(DictionaryCacheEntry* aDict) override {
   return mEntry->SetDictionary(aDict);
 }
 NS_IMETHOD SetBypassWriterLock(bool aBypass) override {
   mEntry->SetBypassWriterLock(aBypass);
   return NS_OK;
 }

 // Specific implementation:
 NS_IMETHOD Dismiss() override;

private:
 virtual ~CacheEntryHandle();
 RefPtr<CacheEntry> mEntry;

 // This is |false| until Dismiss() was called and prevents OnHandleClosed
 // being called more than once.
 Atomic<bool, ReleaseAcquire> mClosed{false};
};

class CacheOutputCloseListener final : public Runnable {
public:
 void OnOutputClosed();

private:
 friend class CacheEntry;

 virtual ~CacheOutputCloseListener() = default;

 NS_DECL_NSIRUNNABLE
 explicit CacheOutputCloseListener(CacheEntry* aEntry);

private:
 RefPtr<CacheEntry> mEntry;
};

}  // namespace net
}  // namespace mozilla

#endif