Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 268 insertions, 0 deletions

diff --git a/netwerk/cache2/OldWrappers.h b/netwerk/cache2/OldWrappers.h
new file mode 100644
index 0000000000..46a2f222b6
--- /dev/null
+++ b/netwerk/cache2/OldWrappers.h
@@ -0,0 +1,268 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+// Stuff to link the old imp to the new api - will go away!
+
+#ifndef OLDWRAPPERS__H__
+#define OLDWRAPPERS__H__
+
+#include "nsICacheEntry.h"
+#include "nsICacheListener.h"
+#include "nsICacheStorage.h"
+
+#include "nsCOMPtr.h"
+#include "nsICacheEntryOpenCallback.h"
+#include "nsICacheEntryDescriptor.h"
+#include "nsICacheStorageVisitor.h"
+#include "nsThreadUtils.h"
+#include "mozilla/TimeStamp.h"
+
+class nsIURI;
+class nsICacheEntryOpenCallback;
+class nsICacheStorageConsumptionObserver;
+class nsIApplicationCache;
+class nsILoadContextInfo;
+
+namespace mozilla {
+namespace net {
+
+class CacheStorage;
+
+class _OldCacheEntryWrapper : public nsICacheEntry {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  // nsICacheEntryDescriptor
+  NS_IMETHOD SetExpirationTime(uint32_t expirationTime) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->SetExpirationTime(expirationTime);
+  }
+  nsresult OpenInputStream(uint32_t offset, nsIInputStream** _retval) {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->OpenInputStream(offset, _retval);
+  }
+  nsresult OpenOutputStream(uint32_t offset, nsIOutputStream** _retval) {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->OpenOutputStream(offset, _retval);
+  }
+  NS_IMETHOD OpenAlternativeOutputStream(
+      const nsACString& type, int64_t predictedSize,
+      nsIAsyncOutputStream** _retval) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  NS_IMETHOD OpenAlternativeInputStream(const nsACString& type,
+                                        nsIInputStream** _retval) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  NS_IMETHOD GetSecurityInfo(nsISupports** aSecurityInfo) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->GetSecurityInfo(aSecurityInfo);
+  }
+  NS_IMETHOD SetSecurityInfo(nsISupports* aSecurityInfo) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->SetSecurityInfo(aSecurityInfo);
+  }
+  NS_IMETHOD GetStorageDataSize(uint32_t* aStorageDataSize) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->GetStorageDataSize(aStorageDataSize);
+  }
+  nsresult AsyncDoom(nsICacheListener* listener) {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER : mOldDesc->AsyncDoom(listener);
+  }
+  NS_IMETHOD MarkValid(void) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER : mOldDesc->MarkValid();
+  }
+  NS_IMETHOD Close(void) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER : mOldDesc->Close();
+  }
+  NS_IMETHOD GetMetaDataElement(const char* key, char** _retval) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->GetMetaDataElement(key, _retval);
+  }
+  NS_IMETHOD SetMetaDataElement(const char* key, const char* value) override {
+    return !mOldDesc ? NS_ERROR_NULL_POINTER
+                     : mOldDesc->SetMetaDataElement(key, value);
+  }
+
+  NS_IMETHOD GetDiskStorageSizeInKB(uint32_t* aDiskStorageSize) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  // nsICacheEntryInfo
+  NS_IMETHOD GetKey(nsACString& aKey) override {
+    return mOldInfo->GetKey(aKey);
+  }
+  NS_IMETHOD GetCacheEntryId(uint64_t* aCacheEntryId) override {
+    *aCacheEntryId = mCacheEntryId;
+    return NS_OK;
+  }
+  NS_IMETHOD GetFetchCount(int32_t* aFetchCount) override {
+    return mOldInfo->GetFetchCount(aFetchCount);
+  }
+  NS_IMETHOD GetLastFetched(uint32_t* aLastFetched) override {
+    return mOldInfo->GetLastFetched(aLastFetched);
+  }
+  NS_IMETHOD GetLastModified(uint32_t* aLastModified) override {
+    return mOldInfo->GetLastModified(aLastModified);
+  }
+  NS_IMETHOD GetExpirationTime(uint32_t* aExpirationTime) override {
+    return mOldInfo->GetExpirationTime(aExpirationTime);
+  }
+  nsresult GetDataSize(uint32_t* aDataSize) {
+    return mOldInfo->GetDataSize(aDataSize);
+  }
+  NS_IMETHOD GetOnStartTime(uint64_t* aTime) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  NS_IMETHOD GetOnStopTime(uint64_t* aTime) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  NS_IMETHOD SetNetworkTimes(uint64_t aOnStartTime,
+                             uint64_t aOnStopTime) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  NS_IMETHOD SetContentType(uint8_t aContentType) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  NS_IMETHOD GetLoadContextInfo(nsILoadContextInfo** aInfo) override {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  NS_IMETHOD Dismiss() override { return NS_ERROR_NOT_IMPLEMENTED; }
+
+  NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener) override;
+  NS_IMETHOD GetPersistent(bool* aPersistToDisk) override;
+  NS_IMETHOD GetIsForcedValid(bool* aIsForcedValid) override;
+  NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture) override;
+  NS_IMETHOD SetValid() override { return NS_OK; }
+  NS_IMETHOD MetaDataReady() override { return NS_OK; }
+  NS_IMETHOD Recreate(bool, nsICacheEntry**) override;
+  NS_IMETHOD GetDataSize(int64_t* size) override;
+  NS_IMETHOD GetAltDataSize(int64_t* size) override;
+  NS_IMETHOD GetAltDataType(nsACString& aType) override;
+  NS_IMETHOD OpenInputStream(int64_t offset, nsIInputStream** _retval) override;
+  NS_IMETHOD OpenOutputStream(int64_t offset, int64_t predictedSize,
+                              nsIOutputStream** _retval) override;
+  NS_IMETHOD MaybeMarkValid() override;
+  NS_IMETHOD HasWriteAccess(bool aWriteOnly, bool* aWriteAccess) override;
+  NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*) override;
+
+  explicit _OldCacheEntryWrapper(nsICacheEntryDescriptor* desc);
+  explicit _OldCacheEntryWrapper(nsICacheEntryInfo* info);
+
+ private:
+  virtual ~_OldCacheEntryWrapper();
+
+  _OldCacheEntryWrapper() = delete;
+  nsICacheEntryDescriptor* mOldDesc;  // ref holded in mOldInfo
+  nsCOMPtr<nsICacheEntryInfo> mOldInfo;
+
+  const uint64_t mCacheEntryId;
+};
+
+class _OldCacheLoad : public Runnable, public nsICacheListener {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIRUNNABLE
+  NS_DECL_NSICACHELISTENER
+
+  _OldCacheLoad(const nsACString& aScheme, const nsACString& aCacheKey,
+                nsICacheEntryOpenCallback* aCallback,
+                nsIApplicationCache* aAppCache, nsILoadContextInfo* aLoadInfo,
+                bool aWriteToDisk, uint32_t aFlags);
+
+  nsresult Start();
+
+ protected:
+  virtual ~_OldCacheLoad();
+
+ private:
+  void Check();
+
+  nsCOMPtr<nsIEventTarget> mCacheThread;
+
+  nsCString const mScheme;
+  nsCString const mCacheKey;
+  nsCOMPtr<nsICacheEntryOpenCallback> mCallback;
+  nsCOMPtr<nsILoadContextInfo> mLoadInfo;
+  uint32_t const mFlags;
+
+  bool const mWriteToDisk : 1;
+  bool mNew : 1;
+  bool mOpening : 1;
+  bool mSync : 1;
+
+  nsCOMPtr<nsICacheEntry> mCacheEntry;
+  nsresult mStatus;
+  uint32_t mRunCount;
+  nsCOMPtr<nsIApplicationCache> mAppCache;
+
+  mozilla::TimeStamp mLoadStart;
+};
+
+class _OldStorage : public nsICacheStorage {
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSICACHESTORAGE
+
+ public:
+  _OldStorage(nsILoadContextInfo* aInfo, bool aAllowDisk, bool aLookupAppCache,
+              bool aOfflineStorage, nsIApplicationCache* aAppCache);
+
+ private:
+  virtual ~_OldStorage();
+  nsresult AssembleCacheKey(nsIURI* aURI, nsACString const& aIdExtension,
+                            nsACString& aCacheKey, nsACString& aScheme);
+  nsresult ChooseApplicationCache(const nsACString& cacheKey,
+                                  nsIApplicationCache** aCache);
+
+  nsCOMPtr<nsILoadContextInfo> mLoadInfo;
+  nsCOMPtr<nsIApplicationCache> mAppCache;
+  bool const mWriteToDisk : 1;
+  bool const mLookupAppCache : 1;
+  bool const mOfflineStorage : 1;
+};
+
+class _OldVisitCallbackWrapper : public nsICacheVisitor {
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSICACHEVISITOR
+
+  _OldVisitCallbackWrapper(char const* deviceID, nsICacheStorageVisitor* cb,
+                           bool visitEntries, nsILoadContextInfo* aInfo)
+      : mCB(cb),
+        mVisitEntries(visitEntries),
+        mDeviceID(deviceID),
+        mLoadInfo(aInfo),
+        mHit(false) {}
+
+ private:
+  virtual ~_OldVisitCallbackWrapper();
+  nsCOMPtr<nsICacheStorageVisitor> mCB;
+  bool mVisitEntries;
+  char const* mDeviceID;
+  nsCOMPtr<nsILoadContextInfo> mLoadInfo;
+  bool mHit;  // set to true when the device was found
+};
+
+class _OldGetDiskConsumption : public Runnable, public nsICacheVisitor {
+ public:
+  static nsresult Get(nsICacheStorageConsumptionObserver* aCallback);
+
+ private:
+  explicit _OldGetDiskConsumption(
+      nsICacheStorageConsumptionObserver* aCallback);
+  virtual ~_OldGetDiskConsumption() = default;
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSICACHEVISITOR
+  NS_DECL_NSIRUNNABLE
+
+  nsCOMPtr<nsICacheStorageConsumptionObserver> mCallback;
+  int64_t mSize;
+};
+
+}  // namespace net
+}  // namespace mozilla
+
+#endif