Source code
Revision control
Copy as Markdown
Other Tools
/* 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
#ifndef CacheFile__h__
#define CacheFile__h__
#include "CacheFileChunk.h"
#include "CacheFileIOManager.h"
#include "CacheFileMetadata.h"
#include "nsRefPtrHashtable.h"
#include "nsClassHashtable.h"
#include "mozilla/Mutex.h"
class nsIAsyncOutputStream;
class nsICacheEntry;
class nsICacheEntryMetaDataVisitor;
class nsIInputStream;
class nsIOutputStream;
namespace mozilla {
namespace net {
class CacheFileInputStream;
class CacheFileOutputStream;
class CacheOutputCloseListener;
class MetadataWriteTimer;
namespace CacheFileUtils {
class CacheFileLock;
};
#define CACHEFILELISTENER_IID \
{ /* 95e7f284-84ba-48f9-b1fc-3a7336b4c33c */ \
0x95e7f284, 0x84ba, 0x48f9, { \
0xb1, 0xfc, 0x3a, 0x73, 0x36, 0xb4, 0xc3, 0x3c \
} \
}
class CacheFileListener : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(CACHEFILELISTENER_IID)
NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew) = 0;
NS_IMETHOD OnFileDoomed(nsresult aResult) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(CacheFileListener, CACHEFILELISTENER_IID)
class MOZ_CAPABILITY("mutex") CacheFile final
: public CacheFileChunkListener,
public CacheFileIOListener,
public CacheFileMetadataListener {
public:
NS_DECL_THREADSAFE_ISUPPORTS
CacheFile();
nsresult Init(const nsACString& aKey, bool aCreateNew, bool aMemoryOnly,
bool aSkipSizeCheck, bool aPriority, bool aPinned,
CacheFileListener* aCallback);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk* aChunk) override;
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk* aChunk) override;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
CacheFileChunk* aChunk) override;
NS_IMETHOD OnChunkUpdated(CacheFileChunk* aChunk) override;
NS_IMETHOD OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) override;
NS_IMETHOD OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
nsresult aResult) override;
NS_IMETHOD OnDataRead(CacheFileHandle* aHandle, char* aBuf,
nsresult aResult) override;
NS_IMETHOD OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) override;
NS_IMETHOD OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) override;
NS_IMETHOD OnFileRenamed(CacheFileHandle* aHandle, nsresult aResult) override;
virtual bool IsKilled() override;
NS_IMETHOD OnMetadataRead(nsresult aResult) override;
NS_IMETHOD OnMetadataWritten(nsresult aResult) override;
NS_IMETHOD OpenInputStream(nsICacheEntry* aCacheEntryHandle,
nsIInputStream** _retval);
NS_IMETHOD OpenAlternativeInputStream(nsICacheEntry* aCacheEntryHandle,
const char* aAltDataType,
nsIInputStream** _retval);
NS_IMETHOD OpenOutputStream(CacheOutputCloseListener* aCloseListener,
nsIOutputStream** _retval);
NS_IMETHOD OpenAlternativeOutputStream(
CacheOutputCloseListener* aCloseListener, const char* aAltDataType,
nsIAsyncOutputStream** _retval);
NS_IMETHOD SetMemoryOnly();
NS_IMETHOD Doom(CacheFileListener* aCallback);
void Kill() { mKill = true; }
nsresult ThrowMemoryCachedData();
nsresult GetAltDataSize(int64_t* aSize);
nsresult GetAltDataType(nsACString& aType);
// metadata forwarders
nsresult GetElement(const char* aKey, char** _retval);
nsresult SetElement(const char* aKey, const char* aValue);
nsresult VisitMetaData(nsICacheEntryMetaDataVisitor* aVisitor);
nsresult ElementsSize(uint32_t* _retval);
nsresult SetExpirationTime(uint32_t aExpirationTime);
nsresult GetExpirationTime(uint32_t* _retval);
nsresult SetFrecency(uint32_t aFrecency);
nsresult GetFrecency(uint32_t* _retval);
nsresult SetNetworkTimes(uint64_t aOnStartTime, uint64_t aOnStopTime);
nsresult SetContentType(uint8_t aContentType);
nsresult GetOnStartTime(uint64_t* _retval);
nsresult GetOnStopTime(uint64_t* _retval);
nsresult GetLastModified(uint32_t* _retval);
nsresult GetLastFetched(uint32_t* _retval);
nsresult GetFetchCount(uint32_t* _retval);
nsresult GetDiskStorageSizeInKB(uint32_t* aDiskStorageSize);
// Called by upper layers to indicated the entry has been fetched,
// i.e. delivered to the consumer.
nsresult OnFetched();
bool DataSize(int64_t* aSize);
void Key(nsACString& aKey);
bool IsDoomed();
bool IsPinned();
// Returns true when there is a potentially unfinished write operation.
bool IsWriteInProgress();
bool EntryWouldExceedLimit(int64_t aOffset, int64_t aSize, bool aIsAltData);
// Memory reporting
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
private:
friend class CacheFileIOManager;
friend class CacheFileChunk;
friend class CacheFileInputStream;
friend class CacheFileOutputStream;
friend class CacheFileAutoLock;
friend class MetadataWriteTimer;
virtual ~CacheFile();
void Lock() MOZ_CAPABILITY_ACQUIRE() { mLock->Lock().Lock(); }
void Unlock() MOZ_CAPABILITY_RELEASE() {
// move the elements out of mObjsToRelease
// so that they can be released after we unlock
nsTArray<RefPtr<nsISupports>> objs = std::move(mObjsToRelease);
mLock->Lock().Unlock();
}
void AssertOwnsLock() const MOZ_ASSERT_CAPABILITY(this) {
mLock->Lock().AssertCurrentThreadOwns();
}
void ReleaseOutsideLock(RefPtr<nsISupports> aObject);
enum ECallerType { READER = 0, WRITER = 1, PRELOADER = 2 };
nsresult DoomLocked(CacheFileListener* aCallback);
nsresult GetChunkLocked(uint32_t aIndex, ECallerType aCaller,
CacheFileChunkListener* aCallback,
CacheFileChunk** _retval);
void PreloadChunks(uint32_t aIndex);
bool ShouldCacheChunk(uint32_t aIndex);
bool MustKeepCachedChunk(uint32_t aIndex);
nsresult DeactivateChunk(CacheFileChunk* aChunk);
void RemoveChunkInternal(CacheFileChunk* aChunk, bool aCacheChunk);
bool OutputStreamExists(bool aAlternativeData);
// Returns number of bytes that are available and can be read by input stream
// without waiting for the data. The amount is counted from the start of
// aIndex chunk and it is guaranteed that this data won't be released by
// CleanUpCachedChunks().
int64_t BytesFromChunk(uint32_t aIndex, bool aAlternativeData);
nsresult Truncate(int64_t aOffset);
void RemoveInput(CacheFileInputStream* aInput, nsresult aStatus);
void RemoveOutput(CacheFileOutputStream* aOutput, nsresult aStatus);
nsresult NotifyChunkListener(CacheFileChunkListener* aCallback,
nsIEventTarget* aTarget, nsresult aResult,
uint32_t aChunkIdx, CacheFileChunk* aChunk);
void QueueChunkListener(uint32_t aIndex, CacheFileChunkListener* aCallback);
nsresult NotifyChunkListeners(uint32_t aIndex, nsresult aResult,
CacheFileChunk* aChunk);
bool HaveChunkListeners(uint32_t aIndex);
void NotifyListenersAboutOutputRemoval();
bool IsDirty() MOZ_REQUIRES(this);
void WriteMetadataIfNeeded();
void WriteMetadataIfNeededLocked(bool aFireAndForget = false)
MOZ_REQUIRES(this);
void PostWriteTimer() MOZ_REQUIRES(this);
void CleanUpCachedChunks() MOZ_REQUIRES(this);
nsresult PadChunkWithZeroes(uint32_t aChunkIdx);
void SetError(nsresult aStatus);
nsresult SetAltMetadata(const char* aAltMetadata);
nsresult InitIndexEntry();
bool mOpeningFile MOZ_GUARDED_BY(this){false};
bool mReady MOZ_GUARDED_BY(this){false};
bool mMemoryOnly MOZ_GUARDED_BY(this){false};
bool mSkipSizeCheck MOZ_GUARDED_BY(this){false};
bool mOpenAsMemoryOnly MOZ_GUARDED_BY(this){false};
bool mPinned MOZ_GUARDED_BY(this){false};
bool mPriority MOZ_GUARDED_BY(this){false};
bool mDataAccessed MOZ_GUARDED_BY(this){false};
bool mDataIsDirty MOZ_GUARDED_BY(this){false};
bool mWritingMetadata MOZ_GUARDED_BY(this){false};
bool mPreloadWithoutInputStreams MOZ_GUARDED_BY(this){true};
uint32_t mPreloadChunkCount MOZ_GUARDED_BY(this){0};
nsresult mStatus MOZ_GUARDED_BY(this){NS_OK};
// Size of the whole data including eventual alternative data represenation.
int64_t mDataSize MOZ_GUARDED_BY(this){-1};
// If there is alternative data present, it contains size of the original
// data, i.e. offset where alternative data starts. Otherwise it is -1.
int64_t mAltDataOffset MOZ_GUARDED_BY(this){-1};
nsCString mKey MOZ_GUARDED_BY(this);
nsCString mAltDataType
MOZ_GUARDED_BY(this); // The type of the saved alt-data. May be empty.
RefPtr<CacheFileHandle> mHandle MOZ_GUARDED_BY(this);
RefPtr<CacheFileMetadata> mMetadata MOZ_GUARDED_BY(this);
nsCOMPtr<CacheFileListener> mListener MOZ_GUARDED_BY(this);
nsCOMPtr<CacheFileIOListener> mDoomAfterOpenListener MOZ_GUARDED_BY(this);
Atomic<bool, Relaxed> mKill{false};
nsRefPtrHashtable<nsUint32HashKey, CacheFileChunk> mChunks
MOZ_GUARDED_BY(this);
nsClassHashtable<nsUint32HashKey, ChunkListeners> mChunkListeners
MOZ_GUARDED_BY(this);
nsRefPtrHashtable<nsUint32HashKey, CacheFileChunk> mCachedChunks
MOZ_GUARDED_BY(this);
// We can truncate data only if there is no input/output stream beyond the
// truncate position, so only unused chunks can be thrown away. But it can
// happen that we need to throw away a chunk that is still in mChunks (i.e.
// an active chunk) because deactivation happens with a small delay. We cannot
// delete such chunk immediately but we need to ensure that such chunk won't
// be returned by GetChunkLocked, so we move this chunk into mDiscardedChunks
// and mark it as discarded.
nsTArray<RefPtr<CacheFileChunk>> mDiscardedChunks MOZ_GUARDED_BY(this);
nsTArray<CacheFileInputStream*> mInputs MOZ_GUARDED_BY(this);
CacheFileOutputStream* mOutput MOZ_GUARDED_BY(this){nullptr};
nsTArray<RefPtr<nsISupports>> mObjsToRelease MOZ_GUARDED_BY(this);
RefPtr<CacheFileUtils::CacheFileLock> mLock;
};
class MOZ_RAII MOZ_SCOPED_CAPABILITY CacheFileAutoLock {
public:
explicit CacheFileAutoLock(CacheFile* aFile) MOZ_CAPABILITY_ACQUIRE(aFile)
: mFile(aFile), mLocked(true) {
mFile->Lock();
}
~CacheFileAutoLock() MOZ_CAPABILITY_RELEASE() {
if (mLocked) {
mFile->Unlock();
}
}
void Lock() MOZ_CAPABILITY_ACQUIRE() {
MOZ_ASSERT(!mLocked);
mFile->Lock();
mLocked = true;
}
void Unlock() MOZ_CAPABILITY_RELEASE() {
MOZ_ASSERT(mLocked);
mFile->Unlock();
mLocked = false;
}
private:
RefPtr<CacheFile> mFile;
bool mLocked;
};
} // namespace net
} // namespace mozilla
#endif