bf3516e81e
In modern C++, static constexpr member variables are automatically inline (aka weak) so the template trick is not needed. This also avoid duplication and reduces the amount of parsed code. No impact on generated binary (actually: smaller debuginfo, close to identical binary). Differential Revision: https://phabricator.services.mozilla.com/D247825
244 lines
8.2 KiB
C++
244 lines
8.2 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 CacheFileMetadata__h__
|
|
#define CacheFileMetadata__h__
|
|
|
|
#include "CacheFileIOManager.h"
|
|
#include "CacheStorageService.h"
|
|
#include "CacheHashUtils.h"
|
|
#include "CacheObserver.h"
|
|
#include "mozilla/EndianUtils.h"
|
|
#include "mozilla/BasePrincipal.h"
|
|
#include "mozilla/NotNull.h"
|
|
#include "nsString.h"
|
|
|
|
class nsICacheEntryMetaDataVisitor;
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
namespace CacheFileUtils {
|
|
class CacheFileLock;
|
|
};
|
|
|
|
// Flags stored in CacheFileMetadataHeader.mFlags
|
|
|
|
// Whether an entry is a pinned entry (created with
|
|
// nsICacheStorageService.pinningCacheStorage.)
|
|
static const uint32_t kCacheEntryIsPinned = 1 << 0;
|
|
|
|
// By multiplying with the current half-life we convert the frecency
|
|
// to time independent of half-life value. The range fits 32bits.
|
|
// When decay time changes on next run of the browser, we convert
|
|
// the frecency value to a correct internal representation again.
|
|
// It might not be 100% accurate, but for the purpose it suffice.
|
|
#define FRECENCY2INT(aFrecency) \
|
|
((uint32_t)((aFrecency) * CacheObserver::HalfLifeSeconds()))
|
|
#define INT2FRECENCY(aInt) \
|
|
((double)(aInt) / (double)CacheObserver::HalfLifeSeconds())
|
|
|
|
#define kCacheEntryVersion 3
|
|
|
|
#pragma pack(push)
|
|
#pragma pack(1)
|
|
|
|
class CacheFileMetadataHeader {
|
|
public:
|
|
uint32_t mVersion;
|
|
uint32_t mFetchCount;
|
|
uint32_t mLastFetched;
|
|
uint32_t mLastModified;
|
|
uint32_t mFrecency;
|
|
uint32_t mExpirationTime;
|
|
uint32_t mKeySize;
|
|
uint32_t mFlags;
|
|
|
|
void WriteToBuf(void* aBuf) {
|
|
EnsureCorrectClassSize();
|
|
|
|
uint8_t* ptr = static_cast<uint8_t*>(aBuf);
|
|
MOZ_ASSERT(mVersion == kCacheEntryVersion);
|
|
NetworkEndian::writeUint32(ptr, mVersion);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mFetchCount);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mLastFetched);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mLastModified);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mFrecency);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mExpirationTime);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mKeySize);
|
|
ptr += sizeof(uint32_t);
|
|
NetworkEndian::writeUint32(ptr, mFlags);
|
|
}
|
|
|
|
void ReadFromBuf(const void* aBuf) {
|
|
EnsureCorrectClassSize();
|
|
|
|
const uint8_t* ptr = static_cast<const uint8_t*>(aBuf);
|
|
mVersion = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
mFetchCount = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
mLastFetched = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
mLastModified = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
mFrecency = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
mExpirationTime = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
mKeySize = BigEndian::readUint32(ptr);
|
|
ptr += sizeof(uint32_t);
|
|
if (mVersion >= 2) {
|
|
mFlags = BigEndian::readUint32(ptr);
|
|
} else {
|
|
mFlags = 0;
|
|
}
|
|
}
|
|
|
|
inline void EnsureCorrectClassSize() {
|
|
static_assert(
|
|
(sizeof(mVersion) + sizeof(mFetchCount) + sizeof(mLastFetched) +
|
|
sizeof(mLastModified) + sizeof(mFrecency) + sizeof(mExpirationTime) +
|
|
sizeof(mKeySize)) +
|
|
sizeof(mFlags) ==
|
|
sizeof(CacheFileMetadataHeader),
|
|
"Unexpected sizeof(CacheFileMetadataHeader)!");
|
|
}
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
#define CACHEFILEMETADATALISTENER_IID \
|
|
{/* a9e36125-3f01-4020-9540-9dafa8d31ba7 */ \
|
|
0xa9e36125, \
|
|
0x3f01, \
|
|
0x4020, \
|
|
{0x95, 0x40, 0x9d, 0xaf, 0xa8, 0xd3, 0x1b, 0xa7}}
|
|
|
|
class CacheFileMetadataListener : public nsISupports {
|
|
public:
|
|
NS_INLINE_DECL_STATIC_IID(CACHEFILEMETADATALISTENER_IID)
|
|
|
|
NS_IMETHOD OnMetadataRead(nsresult aResult) = 0;
|
|
NS_IMETHOD OnMetadataWritten(nsresult aResult) = 0;
|
|
virtual bool IsKilled() = 0;
|
|
};
|
|
|
|
class CacheFileMetadata final : public CacheFileIOListener,
|
|
public CacheMemoryConsumer {
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
|
|
CacheFileMetadata(CacheFileHandle* aHandle, const nsACString& aKey,
|
|
NotNull<CacheFileUtils::CacheFileLock*> aLock);
|
|
CacheFileMetadata(bool aMemoryOnly, bool aPinned, const nsACString& aKey,
|
|
NotNull<CacheFileUtils::CacheFileLock*> aLock);
|
|
CacheFileMetadata();
|
|
|
|
void SetHandle(CacheFileHandle* aHandle);
|
|
|
|
const nsACString& GetKey() const { return mKey; }
|
|
|
|
void ReadMetadata(CacheFileMetadataListener* aListener);
|
|
uint32_t CalcMetadataSize(uint32_t aElementsSize, uint32_t aHashCount);
|
|
nsresult WriteMetadata(uint32_t aOffset,
|
|
CacheFileMetadataListener* aListener);
|
|
nsresult SyncReadMetadata(nsIFile* aFile);
|
|
|
|
bool IsAnonymous() const { return mAnonymous; }
|
|
mozilla::OriginAttributes const& OriginAttributes() const {
|
|
return mOriginAttributes;
|
|
}
|
|
bool Pinned() const { return !!(mMetaHdr.mFlags & kCacheEntryIsPinned); }
|
|
|
|
const char* GetElement(const char* aKey);
|
|
void HandleCorruptMetaData() const;
|
|
nsresult SetElement(const char* aKey, const char* aValue);
|
|
void Visit(nsICacheEntryMetaDataVisitor* aVisitor);
|
|
|
|
CacheHash::Hash16_t GetHash(uint32_t aIndex);
|
|
nsresult SetHash(uint32_t aIndex, CacheHash::Hash16_t aHash);
|
|
nsresult RemoveHash(uint32_t aIndex);
|
|
|
|
void AddFlags(uint32_t aFlags);
|
|
void RemoveFlags(uint32_t aFlags);
|
|
uint32_t GetFlags() const { return mMetaHdr.mFlags; }
|
|
void SetExpirationTime(uint32_t aExpirationTime);
|
|
uint32_t GetExpirationTime() const { return mMetaHdr.mExpirationTime; }
|
|
void SetFrecency(uint32_t aFrecency);
|
|
uint32_t GetFrecency() const { return mMetaHdr.mFrecency; }
|
|
uint32_t GetLastModified() const { return mMetaHdr.mLastModified; }
|
|
uint32_t GetLastFetched() const { return mMetaHdr.mLastFetched; }
|
|
uint32_t GetFetchCount() const { return mMetaHdr.mFetchCount; }
|
|
// Called by upper layers to indicate the entry this metadata belongs
|
|
// with has been fetched, i.e. delivered to the consumer.
|
|
void OnFetched();
|
|
|
|
int64_t Offset() { return mOffset; }
|
|
uint32_t ElementsSize() { return mElementsSize; }
|
|
void MarkDirty(bool aUpdateLastModified = true);
|
|
bool IsDirty() { return mIsDirty; }
|
|
uint32_t MemoryUsage() {
|
|
return sizeof(CacheFileMetadata) + mHashArraySize + mBufSize;
|
|
}
|
|
|
|
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 {
|
|
return mListener && mListener->IsKilled();
|
|
}
|
|
void InitEmptyMetadata();
|
|
|
|
// Memory reporting
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
|
|
private:
|
|
virtual ~CacheFileMetadata();
|
|
|
|
nsresult ParseMetadata(uint32_t aMetaOffset, uint32_t aBufOffset,
|
|
bool aHaveKey);
|
|
nsresult CheckElements(const char* aBuf, uint32_t aSize);
|
|
nsresult EnsureBuffer(uint32_t aSize);
|
|
nsresult ParseKey(const nsACString& aKey);
|
|
|
|
RefPtr<CacheFileHandle> mHandle;
|
|
nsCString mKey;
|
|
CacheHash::Hash16_t* mHashArray{nullptr};
|
|
uint32_t mHashArraySize{0};
|
|
uint32_t mHashCount{0};
|
|
int64_t mOffset{0};
|
|
// used for parsing, then points to elements
|
|
char* mBuf{nullptr};
|
|
uint32_t mBufSize{0};
|
|
char* mWriteBuf{nullptr};
|
|
CacheFileMetadataHeader mMetaHdr{0};
|
|
uint32_t mElementsSize{0};
|
|
bool mIsDirty : 1;
|
|
bool mAnonymous : 1;
|
|
bool mAllocExactSize : 1;
|
|
bool mFirstRead : 1;
|
|
mozilla::OriginAttributes mOriginAttributes;
|
|
mozilla::TimeStamp mReadStart;
|
|
nsCOMPtr<CacheFileMetadataListener> mListener;
|
|
RefPtr<CacheFileUtils::CacheFileLock> mLock;
|
|
};
|
|
|
|
} // namespace net
|
|
} // namespace mozilla
|
|
|
|
#endif
|