DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (19cf79b6f07d)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
/* 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 "nsAutoPtr.h"
#include "nsString.h"

class nsICacheEntryMetaDataVisitor;

namespace mozilla {
namespace net {

// 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_DECLARE_STATIC_IID_ACCESSOR(CACHEFILEMETADATALISTENER_IID)

  NS_IMETHOD OnMetadataRead(nsresult aResult) = 0;
  NS_IMETHOD OnMetadataWritten(nsresult aResult) = 0;
  virtual bool IsKilled() = 0;
};

NS_DEFINE_STATIC_IID_ACCESSOR(CacheFileMetadataListener,
                              CACHEFILEMETADATALISTENER_IID)

class CacheFileMetadata final : public CacheFileIOListener,
                                public CacheMemoryConsumer {
 public:
  NS_DECL_THREADSAFE_ISUPPORTS

  CacheFileMetadata(CacheFileHandle* aHandle, const nsACString& aKey);
  CacheFileMetadata(bool aMemoryOnly, bool aPinned, const nsACString& aKey);
  CacheFileMetadata();

  void SetHandle(CacheFileHandle* aHandle);

  nsresult GetKey(nsACString& _retval);

  nsresult 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);
  nsresult SetElement(const char* aKey, const char* aValue);
  nsresult Visit(nsICacheEntryMetaDataVisitor* aVisitor);

  CacheHash::Hash16_t GetHash(uint32_t aIndex);
  nsresult SetHash(uint32_t aIndex, CacheHash::Hash16_t aHash);
  nsresult RemoveHash(uint32_t aIndex);

  nsresult AddFlags(uint32_t aFlags);
  nsresult RemoveFlags(uint32_t aFlags);
  nsresult GetFlags(uint32_t* _retval);
  nsresult SetExpirationTime(uint32_t aExpirationTime);
  nsresult GetExpirationTime(uint32_t* _retval);
  nsresult SetFrecency(uint32_t aFrecency);
  nsresult GetFrecency(uint32_t* _retval);
  nsresult GetLastModified(uint32_t* _retval);
  nsresult GetLastFetched(uint32_t* _retval);
  nsresult GetFetchCount(uint32_t* _retval);
  // Called by upper layers to indicate the entry this metadata belongs
  // with has been fetched, i.e. delivered to the consumer.
  nsresult 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;
  uint32_t mHashArraySize;
  uint32_t mHashCount;
  int64_t mOffset;
  char* mBuf;  // used for parsing, then points
               // to elements
  uint32_t mBufSize;
  char* mWriteBuf;
  CacheFileMetadataHeader mMetaHdr;
  uint32_t mElementsSize;
  bool mIsDirty : 1;
  bool mAnonymous : 1;
  bool mAllocExactSize : 1;
  bool mFirstRead : 1;
  mozilla::OriginAttributes mOriginAttributes;
  mozilla::TimeStamp mReadStart;
  nsCOMPtr<CacheFileMetadataListener> mListener;
};

}  // namespace net
}  // namespace mozilla

#endif