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 (4a108e94d3e2)

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
/* 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/Endian.h"
#include "nsAutoPtr.h"
#include "nsString.h"

class nsICacheEntryMetaDataVisitor;

namespace mozilla {
namespace net {

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


#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;

  void WriteToBuf(void *aBuf)
  {
    EnsureCorrectClassSize();

    uint8_t* ptr = static_cast<uint8_t*>(aBuf);
    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);
  }

  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);
  }

  inline void EnsureCorrectClassSize()
  {
    static_assert((sizeof(mVersion) + sizeof(mFetchCount) +
      sizeof(mLastFetched) + sizeof(mLastModified) + sizeof(mFrecency) +
      sizeof(mExpirationTime) + sizeof(mKeySize)) ==
      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;
};

NS_DEFINE_STATIC_IID_ACCESSOR(CacheFileMetadataListener,
                              CACHEFILEMETADATALISTENER_IID)


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

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

  void SetHandle(CacheFileHandle *aHandle);

  nsresult GetKey(nsACString &_retval);

  nsresult ReadMetadata(CacheFileMetadataListener *aListener);
  nsresult WriteMetadata(uint32_t aOffset,
                         CacheFileMetadataListener *aListener);
  nsresult SyncReadMetadata(nsIFile *aFile);

  bool     IsAnonymous() { return mAnonymous; }
  bool     IsInBrowser() { return mInBrowser; }
  uint32_t AppId()       { return mAppId; }

  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 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;

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

private:
  virtual ~CacheFileMetadata();

  void     InitEmptyMetadata();
  nsresult ParseMetadata(uint32_t aMetaOffset, uint32_t aBufOffset, bool aHaveKey);
  nsresult CheckElements(const char *aBuf, uint32_t aSize);
  void     EnsureBuffer(uint32_t aSize);
  nsresult ParseKey(const nsACString &aKey);

  nsRefPtr<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;
  bool                                mAnonymous;
  bool                                mInBrowser;
  uint32_t                            mAppId;
  nsCOMPtr<CacheFileMetadataListener> mListener;
};


} // net
} // mozilla

#endif