mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-18 15:55:36 +00:00
ee8f43208a
When writing to alt-data output stream fails for whatever reason, we now try to truncate alternative data and keep the original data instead of dooming the whole entry. The patch also changes how is the predicted size passed to the cache. Instead of a dedicated method it's now an argument of openOutputStream and openAlternativeOutputStream methods which fail in case the entry would exceed the allowed limit.
278 lines
9.6 KiB
C++
278 lines
9.6 KiB
C++
/* 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 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 nsIInputStream;
|
|
class nsIOutputStream;
|
|
class nsICacheEntryMetaDataVisitor;
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
class CacheFileInputStream;
|
|
class CacheFileOutputStream;
|
|
class CacheOutputCloseListener;
|
|
class MetadataWriteTimer;
|
|
|
|
#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 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, nsIOutputStream **_retval);
|
|
NS_IMETHOD SetMemoryOnly();
|
|
NS_IMETHOD Doom(CacheFileListener *aCallback);
|
|
|
|
void Kill() { mKill = true; }
|
|
nsresult ThrowMemoryCachedData();
|
|
|
|
nsresult GetAltDataSize(int64_t *aSize);
|
|
|
|
// 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 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) { aKey = mKey; }
|
|
bool IsDoomed();
|
|
bool IsPinned() const { return mPinned; }
|
|
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();
|
|
void Unlock();
|
|
void AssertOwnsLock() const;
|
|
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);
|
|
|
|
nsresult RemoveInput(CacheFileInputStream *aInput, nsresult aStatus);
|
|
nsresult RemoveOutput(CacheFileOutputStream *aOutput, nsresult aStatus);
|
|
nsresult NotifyChunkListener(CacheFileChunkListener *aCallback,
|
|
nsIEventTarget *aTarget,
|
|
nsresult aResult,
|
|
uint32_t aChunkIdx,
|
|
CacheFileChunk *aChunk);
|
|
nsresult QueueChunkListener(uint32_t aIndex,
|
|
CacheFileChunkListener *aCallback);
|
|
nsresult NotifyChunkListeners(uint32_t aIndex, nsresult aResult,
|
|
CacheFileChunk *aChunk);
|
|
bool HaveChunkListeners(uint32_t aIndex);
|
|
void NotifyListenersAboutOutputRemoval();
|
|
|
|
bool IsDirty();
|
|
void WriteMetadataIfNeeded();
|
|
void WriteMetadataIfNeededLocked(bool aFireAndForget = false);
|
|
void PostWriteTimer();
|
|
|
|
void CleanUpCachedChunks();
|
|
|
|
nsresult PadChunkWithZeroes(uint32_t aChunkIdx);
|
|
|
|
void SetError(nsresult aStatus);
|
|
nsresult SetAltMetadata(const char* aAltMetadata);
|
|
|
|
nsresult InitIndexEntry();
|
|
|
|
mozilla::Mutex mLock;
|
|
bool mOpeningFile;
|
|
bool mReady;
|
|
bool mMemoryOnly;
|
|
bool mSkipSizeCheck;
|
|
bool mOpenAsMemoryOnly;
|
|
bool mPinned;
|
|
bool mPriority;
|
|
bool mDataAccessed;
|
|
bool mDataIsDirty;
|
|
bool mWritingMetadata;
|
|
bool mPreloadWithoutInputStreams;
|
|
uint32_t mPreloadChunkCount;
|
|
nsresult mStatus;
|
|
int64_t mDataSize; // Size of the whole data including eventual
|
|
// alternative data represenation.
|
|
int64_t mAltDataOffset; // If there is alternative data present, it
|
|
// contains size of the original data, i.e.
|
|
// offset where alternative data starts.
|
|
// Otherwise it is -1.
|
|
nsCString mKey;
|
|
|
|
RefPtr<CacheFileHandle> mHandle;
|
|
RefPtr<CacheFileMetadata> mMetadata;
|
|
nsCOMPtr<CacheFileListener> mListener;
|
|
nsCOMPtr<CacheFileIOListener> mDoomAfterOpenListener;
|
|
Atomic<bool, Relaxed> mKill;
|
|
|
|
nsRefPtrHashtable<nsUint32HashKey, CacheFileChunk> mChunks;
|
|
nsClassHashtable<nsUint32HashKey, ChunkListeners> mChunkListeners;
|
|
nsRefPtrHashtable<nsUint32HashKey, CacheFileChunk> mCachedChunks;
|
|
// 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;
|
|
|
|
nsTArray<CacheFileInputStream*> mInputs;
|
|
CacheFileOutputStream *mOutput;
|
|
|
|
nsTArray<RefPtr<nsISupports>> mObjsToRelease;
|
|
};
|
|
|
|
class CacheFileAutoLock {
|
|
public:
|
|
explicit CacheFileAutoLock(CacheFile *aFile)
|
|
: mFile(aFile)
|
|
, mLocked(true)
|
|
{
|
|
mFile->Lock();
|
|
}
|
|
~CacheFileAutoLock()
|
|
{
|
|
if (mLocked)
|
|
mFile->Unlock();
|
|
}
|
|
void Lock()
|
|
{
|
|
MOZ_ASSERT(!mLocked);
|
|
mFile->Lock();
|
|
mLocked = true;
|
|
}
|
|
void Unlock()
|
|
{
|
|
MOZ_ASSERT(mLocked);
|
|
mFile->Unlock();
|
|
mLocked = false;
|
|
}
|
|
|
|
private:
|
|
RefPtr<CacheFile> mFile;
|
|
bool mLocked;
|
|
};
|
|
|
|
} // namespace net
|
|
} // namespace mozilla
|
|
|
|
#endif
|