Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 285 insertions, 0 deletions

diff --git a/netwerk/cache/nsCacheEntry.h b/netwerk/cache/nsCacheEntry.h
new file mode 100644
index 0000000000..ee2a2af35f
--- /dev/null
+++ b/netwerk/cache/nsCacheEntry.h
@@ -0,0 +1,285 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 _nsCacheEntry_h_
+#define _nsCacheEntry_h_
+
+#include "nsICache.h"
+#include "nsICacheEntryDescriptor.h"
+#include "nsCacheMetaData.h"
+
+#include "nspr.h"
+#include "PLDHashTable.h"
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsAString.h"
+
+class nsCacheDevice;
+class nsCacheMetaData;
+class nsCacheRequest;
+class nsCacheEntryDescriptor;
+class nsIEventTarget;
+
+/******************************************************************************
+ * nsCacheEntry
+ *******************************************************************************/
+class nsCacheEntry : public PRCList {
+ public:
+  nsCacheEntry(const nsACString& key, bool streamBased,
+               nsCacheStoragePolicy storagePolicy);
+  ~nsCacheEntry();
+
+  static nsresult Create(const char* key, bool streamBased,
+                         nsCacheStoragePolicy storagePolicy,
+                         nsCacheDevice* device, nsCacheEntry** result);
+
+  nsCString* Key() { return &mKey; }
+
+  int32_t FetchCount() { return mFetchCount; }
+  void SetFetchCount(int32_t count) { mFetchCount = count; }
+  void Fetched();
+
+  uint32_t LastFetched() { return mLastFetched; }
+  void SetLastFetched(uint32_t lastFetched) { mLastFetched = lastFetched; }
+
+  uint32_t LastModified() { return mLastModified; }
+  void SetLastModified(uint32_t lastModified) { mLastModified = lastModified; }
+
+  uint32_t ExpirationTime() { return mExpirationTime; }
+  void SetExpirationTime(uint32_t expires) { mExpirationTime = expires; }
+
+  uint32_t Size() { return mDataSize + mMetaData.Size() + mKey.Length(); }
+
+  nsCacheDevice* CacheDevice() { return mCacheDevice; }
+  void SetCacheDevice(nsCacheDevice* device) { mCacheDevice = device; }
+  void SetCustomCacheDevice(nsCacheDevice* device) { mCustomDevice = device; }
+  nsCacheDevice* CustomCacheDevice() { return mCustomDevice; }
+  const char* GetDeviceID();
+
+  /**
+   * Data accessors
+   */
+  nsISupports* Data() { return mData; }
+  void SetData(nsISupports* data);
+
+  int64_t PredictedDataSize() { return mPredictedDataSize; }
+  void SetPredictedDataSize(int64_t size) { mPredictedDataSize = size; }
+
+  uint32_t DataSize() { return mDataSize; }
+  void SetDataSize(uint32_t size) { mDataSize = size; }
+
+  void TouchData();
+
+  /**
+   * Meta data accessors
+   */
+  const char* GetMetaDataElement(const char* key) {
+    return mMetaData.GetElement(key);
+  }
+  nsresult SetMetaDataElement(const char* key, const char* value) {
+    return mMetaData.SetElement(key, value);
+  }
+  nsresult VisitMetaDataElements(nsICacheMetaDataVisitor* visitor) {
+    return mMetaData.VisitElements(visitor);
+  }
+  nsresult FlattenMetaData(char* buffer, uint32_t bufSize) {
+    return mMetaData.FlattenMetaData(buffer, bufSize);
+  }
+  nsresult UnflattenMetaData(const char* buffer, uint32_t bufSize) {
+    return mMetaData.UnflattenMetaData(buffer, bufSize);
+  }
+  uint32_t MetaDataSize() { return mMetaData.Size(); }
+
+  void TouchMetaData();
+
+  /**
+   * Security Info accessors
+   */
+  nsISupports* SecurityInfo() { return mSecurityInfo; }
+  void SetSecurityInfo(nsISupports* info) { mSecurityInfo = info; }
+
+  // XXX enumerate MetaData method
+
+  enum CacheEntryFlags {
+    eStoragePolicyMask = 0x000000FF,
+    eDoomedMask = 0x00000100,
+    eEntryDirtyMask = 0x00000200,
+    eDataDirtyMask = 0x00000400,
+    eMetaDataDirtyMask = 0x00000800,
+    eStreamDataMask = 0x00001000,
+    eActiveMask = 0x00002000,
+    eInitializedMask = 0x00004000,
+    eValidMask = 0x00008000,
+    eBindingMask = 0x00010000,
+    ePrivateMask = 0x00020000
+  };
+
+  void MarkBinding() { mFlags |= eBindingMask; }
+  void ClearBinding() { mFlags &= ~eBindingMask; }
+  bool IsBinding() { return (mFlags & eBindingMask) != 0; }
+
+  void MarkEntryDirty() { mFlags |= eEntryDirtyMask; }
+  void MarkEntryClean() { mFlags &= ~eEntryDirtyMask; }
+  void MarkDataDirty() { mFlags |= eDataDirtyMask; }
+  void MarkDataClean() { mFlags &= ~eDataDirtyMask; }
+  void MarkMetaDataDirty() { mFlags |= eMetaDataDirtyMask; }
+  void MarkMetaDataClean() { mFlags &= ~eMetaDataDirtyMask; }
+  void MarkStreamData() { mFlags |= eStreamDataMask; }
+  void MarkValid() { mFlags |= eValidMask; }
+  void MarkInvalid() { mFlags &= ~eValidMask; }
+  void MarkPrivate() { mFlags |= ePrivateMask; }
+  void MarkPublic() { mFlags &= ~ePrivateMask; }
+  //    void MarkAllowedInMemory() { mFlags |=  eAllowedInMemoryMask; }
+  //    void MarkAllowedOnDisk()   { mFlags |=  eAllowedOnDiskMask; }
+
+  bool IsDoomed() { return (mFlags & eDoomedMask) != 0; }
+  bool IsEntryDirty() { return (mFlags & eEntryDirtyMask) != 0; }
+  bool IsDataDirty() { return (mFlags & eDataDirtyMask) != 0; }
+  bool IsMetaDataDirty() { return (mFlags & eMetaDataDirtyMask) != 0; }
+  bool IsStreamData() { return (mFlags & eStreamDataMask) != 0; }
+  bool IsActive() { return (mFlags & eActiveMask) != 0; }
+  bool IsInitialized() { return (mFlags & eInitializedMask) != 0; }
+  bool IsValid() { return (mFlags & eValidMask) != 0; }
+  bool IsInvalid() { return (mFlags & eValidMask) == 0; }
+  bool IsInUse() {
+    return IsBinding() ||
+           !(PR_CLIST_IS_EMPTY(&mRequestQ) && PR_CLIST_IS_EMPTY(&mDescriptorQ));
+  }
+  bool IsNotInUse() { return !IsInUse(); }
+  bool IsPrivate() { return (mFlags & ePrivateMask) != 0; }
+
+  bool IsAllowedInMemory() {
+    return (StoragePolicy() == nsICache::STORE_ANYWHERE) ||
+           (StoragePolicy() == nsICache::STORE_IN_MEMORY);
+  }
+
+  bool IsAllowedOnDisk() {
+    return !IsPrivate() && ((StoragePolicy() == nsICache::STORE_ANYWHERE) ||
+                            (StoragePolicy() == nsICache::STORE_ON_DISK));
+  }
+
+  bool IsAllowedOffline() {
+    return (StoragePolicy() == nsICache::STORE_OFFLINE);
+  }
+
+  nsCacheStoragePolicy StoragePolicy() {
+    return (nsCacheStoragePolicy)(mFlags & eStoragePolicyMask);
+  }
+
+  void SetStoragePolicy(nsCacheStoragePolicy policy) {
+    NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy");
+    mFlags &= ~eStoragePolicyMask;  // clear storage policy bits
+    mFlags |= policy;
+  }
+
+  // methods for nsCacheService
+  nsresult RequestAccess(nsCacheRequest* request,
+                         nsCacheAccessMode* accessGranted);
+  nsresult CreateDescriptor(nsCacheRequest* request,
+                            nsCacheAccessMode accessGranted,
+                            nsICacheEntryDescriptor** result);
+
+  bool RemoveRequest(nsCacheRequest* request);
+  bool RemoveDescriptor(nsCacheEntryDescriptor* descriptor, bool* doomEntry);
+
+  void GetDescriptors(
+      nsTArray<RefPtr<nsCacheEntryDescriptor> >& outDescriptors);
+
+ private:
+  friend class nsCacheEntryHashTable;
+  friend class nsCacheService;
+
+  void DetachDescriptors();
+
+  // internal methods
+  void MarkDoomed() { mFlags |= eDoomedMask; }
+  void MarkStreamBased() { mFlags |= eStreamDataMask; }
+  void MarkInitialized() { mFlags |= eInitializedMask; }
+  void MarkActive() { mFlags |= eActiveMask; }
+  void MarkInactive() { mFlags &= ~eActiveMask; }
+
+  nsCString mKey;
+  uint32_t mFetchCount;                 // 4
+  uint32_t mLastFetched;                // 4
+  uint32_t mLastModified;               // 4
+  uint32_t mLastValidated;              // 4
+  uint32_t mExpirationTime;             // 4
+  uint32_t mFlags;                      // 4
+  int64_t mPredictedDataSize;           // Size given by ContentLength.
+  uint32_t mDataSize;                   // 4
+  nsCacheDevice* mCacheDevice;          // 4
+  nsCacheDevice* mCustomDevice;         // 4
+  nsCOMPtr<nsISupports> mSecurityInfo;  //
+  nsISupports* mData;                   // strong ref
+  nsCOMPtr<nsIEventTarget> mEventTarget;
+  nsCacheMetaData mMetaData;  // 4
+  PRCList mRequestQ;          // 8
+  PRCList mDescriptorQ;       // 8
+};
+
+/******************************************************************************
+ * nsCacheEntryInfo
+ *******************************************************************************/
+class nsCacheEntryInfo : public nsICacheEntryInfo {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICACHEENTRYINFO
+
+  explicit nsCacheEntryInfo(nsCacheEntry* entry) : mCacheEntry(entry) {}
+
+  void DetachEntry() { mCacheEntry = nullptr; }
+
+ private:
+  nsCacheEntry* mCacheEntry;
+
+  virtual ~nsCacheEntryInfo() = default;
+};
+
+/******************************************************************************
+ * nsCacheEntryHashTable
+ *******************************************************************************/
+
+struct nsCacheEntryHashTableEntry : public PLDHashEntryHdr {
+  nsCacheEntry* cacheEntry;
+};
+
+class nsCacheEntryHashTable {
+ public:
+  nsCacheEntryHashTable();
+  ~nsCacheEntryHashTable();
+
+  void Init();
+  void Shutdown();
+
+  nsCacheEntry* GetEntry(const nsCString* key) const;
+  nsresult AddEntry(nsCacheEntry* entry);
+  void RemoveEntry(nsCacheEntry* entry);
+
+  PLDHashTable::Iterator Iter();
+
+ private:
+  // PLDHashTable operation callbacks
+  static PLDHashNumber HashKey(const void* key);
+
+  static bool MatchEntry(const PLDHashEntryHdr* entry, const void* key);
+
+  static void MoveEntry(PLDHashTable* table, const PLDHashEntryHdr* from,
+                        PLDHashEntryHdr* to);
+
+  static void ClearEntry(PLDHashTable* table, PLDHashEntryHdr* entry);
+
+  static void Finalize(PLDHashTable* table);
+
+  // member variables
+  static const PLDHashTableOps ops;
+  PLDHashTable table;
+  bool initialized;
+
+  static const uint32_t kInitialTableLength = 256;
+};
+
+#endif  // _nsCacheEntry_h_