summaryrefslogtreecommitdiffstats
path: root/uriloader/prefetch/nsOfflineCacheUpdate.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /uriloader/prefetch/nsOfflineCacheUpdate.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'uriloader/prefetch/nsOfflineCacheUpdate.h')
-rw-r--r--uriloader/prefetch/nsOfflineCacheUpdate.h381
1 files changed, 381 insertions, 0 deletions
diff --git a/uriloader/prefetch/nsOfflineCacheUpdate.h b/uriloader/prefetch/nsOfflineCacheUpdate.h
new file mode 100644
index 000000000..4ccba4135
--- /dev/null
+++ b/uriloader/prefetch/nsOfflineCacheUpdate.h
@@ -0,0 +1,381 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 nsOfflineCacheUpdate_h__
+#define nsOfflineCacheUpdate_h__
+
+#include "nsIOfflineCacheUpdate.h"
+
+#include "nsAutoPtr.h"
+#include "nsCOMArray.h"
+#include "nsCOMPtr.h"
+#include "nsIChannelEventSink.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMNode.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIMutableArray.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIApplicationCache.h"
+#include "nsIRequestObserver.h"
+#include "nsIRunnable.h"
+#include "nsIStreamListener.h"
+#include "nsIURI.h"
+#include "nsIWebProgressListener.h"
+#include "nsClassHashtable.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsWeakReference.h"
+#include "nsICryptoHash.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/WeakPtr.h"
+#include "nsTHashtable.h"
+#include "nsHashKeys.h"
+
+class nsOfflineCacheUpdate;
+
+class nsOfflineCacheUpdateItem : public nsIStreamListener
+ , public nsIRunnable
+ , public nsIInterfaceRequestor
+ , public nsIChannelEventSink
+{
+public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIREQUESTOBSERVER
+ NS_DECL_NSISTREAMLISTENER
+ NS_DECL_NSIRUNNABLE
+ NS_DECL_NSIINTERFACEREQUESTOR
+ NS_DECL_NSICHANNELEVENTSINK
+
+ nsOfflineCacheUpdateItem(nsIURI *aURI,
+ nsIURI *aReferrerURI,
+ nsIPrincipal* aLoadingPrincipal,
+ nsIApplicationCache *aApplicationCache,
+ nsIApplicationCache *aPreviousApplicationCache,
+ uint32_t aType,
+ uint32_t aLoadFlags);
+
+ nsCOMPtr<nsIURI> mURI;
+ nsCOMPtr<nsIURI> mReferrerURI;
+ nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
+ nsCOMPtr<nsIApplicationCache> mApplicationCache;
+ nsCOMPtr<nsIApplicationCache> mPreviousApplicationCache;
+ nsCString mCacheKey;
+ uint32_t mItemType;
+ uint32_t mLoadFlags;
+
+ nsresult OpenChannel(nsOfflineCacheUpdate *aUpdate);
+ nsresult Cancel();
+ nsresult GetRequestSucceeded(bool * succeeded);
+
+ bool IsInProgress();
+ bool IsScheduled();
+ bool IsCompleted();
+
+ nsresult GetStatus(uint16_t *aStatus);
+
+private:
+ enum LoadStatus : uint16_t {
+ UNINITIALIZED = 0U,
+ REQUESTED = 1U,
+ RECEIVING = 2U,
+ LOADED = 3U
+ };
+
+ RefPtr<nsOfflineCacheUpdate> mUpdate;
+ nsCOMPtr<nsIChannel> mChannel;
+ uint16_t mState;
+
+protected:
+ virtual ~nsOfflineCacheUpdateItem();
+
+ int64_t mBytesRead;
+};
+
+
+class nsOfflineManifestItem : public nsOfflineCacheUpdateItem
+{
+public:
+ NS_DECL_NSISTREAMLISTENER
+ NS_DECL_NSIREQUESTOBSERVER
+
+ nsOfflineManifestItem(nsIURI *aURI,
+ nsIURI *aReferrerURI,
+ nsIPrincipal* aLoadingPrincipal,
+ nsIApplicationCache *aApplicationCache,
+ nsIApplicationCache *aPreviousApplicationCache);
+ virtual ~nsOfflineManifestItem();
+
+ nsCOMArray<nsIURI> &GetExplicitURIs() { return mExplicitURIs; }
+ nsCOMArray<nsIURI> &GetAnonymousURIs() { return mAnonymousURIs; }
+ nsCOMArray<nsIURI> &GetFallbackURIs() { return mFallbackURIs; }
+
+ nsTArray<nsCString> &GetOpportunisticNamespaces()
+ { return mOpportunisticNamespaces; }
+ nsIArray *GetNamespaces()
+ { return mNamespaces.get(); }
+
+ bool ParseSucceeded()
+ { return (mParserState != PARSE_INIT && mParserState != PARSE_ERROR); }
+ bool NeedsUpdate() { return mParserState != PARSE_INIT && mNeedsUpdate; }
+
+ void GetManifestHash(nsCString &aManifestHash)
+ { aManifestHash = mManifestHashValue; }
+
+private:
+ static nsresult ReadManifest(nsIInputStream *aInputStream,
+ void *aClosure,
+ const char *aFromSegment,
+ uint32_t aOffset,
+ uint32_t aCount,
+ uint32_t *aBytesConsumed);
+
+ nsresult AddNamespace(uint32_t namespaceType,
+ const nsCString &namespaceSpec,
+ const nsCString &data);
+
+ nsresult HandleManifestLine(const nsCString::const_iterator &aBegin,
+ const nsCString::const_iterator &aEnd);
+
+ /**
+ * Saves "offline-manifest-hash" meta data from the old offline cache
+ * token to mOldManifestHashValue member to be compared on
+ * successfull load.
+ */
+ nsresult GetOldManifestContentHash(nsIRequest *aRequest);
+ /**
+ * This method setups the mNeedsUpdate to false when hash value
+ * of the just downloaded manifest file is the same as stored in cache's
+ * "offline-manifest-hash" meta data. Otherwise stores the new value
+ * to this meta data.
+ */
+ nsresult CheckNewManifestContentHash(nsIRequest *aRequest);
+
+ void ReadStrictFileOriginPolicyPref();
+
+ enum {
+ PARSE_INIT,
+ PARSE_CACHE_ENTRIES,
+ PARSE_FALLBACK_ENTRIES,
+ PARSE_BYPASS_ENTRIES,
+ PARSE_UNKNOWN_SECTION,
+ PARSE_ERROR
+ } mParserState;
+
+ nsCString mReadBuf;
+
+ nsCOMArray<nsIURI> mExplicitURIs;
+ nsCOMArray<nsIURI> mAnonymousURIs;
+ nsCOMArray<nsIURI> mFallbackURIs;
+
+ // All opportunistic caching namespaces. Used to decide whether
+ // to include previously-opportunistically-cached entries.
+ nsTArray<nsCString> mOpportunisticNamespaces;
+
+ // Array of nsIApplicationCacheNamespace objects specified by the
+ // manifest.
+ nsCOMPtr<nsIMutableArray> mNamespaces;
+
+ bool mNeedsUpdate;
+ bool mStrictFileOriginPolicy;
+
+ // manifest hash data
+ nsCOMPtr<nsICryptoHash> mManifestHash;
+ bool mManifestHashInitialized;
+ nsCString mManifestHashValue;
+ nsCString mOldManifestHashValue;
+};
+
+class nsOfflineCacheUpdateOwner
+ : public mozilla::SupportsWeakPtr<nsOfflineCacheUpdateOwner>
+{
+public:
+ MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsOfflineCacheUpdateOwner)
+ virtual ~nsOfflineCacheUpdateOwner() {}
+ virtual nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate) = 0;
+};
+
+class nsOfflineCacheUpdate final : public nsIOfflineCacheUpdate
+ , public nsIOfflineCacheUpdateObserver
+ , public nsIRunnable
+ , public nsOfflineCacheUpdateOwner
+{
+public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOFFLINECACHEUPDATE
+ NS_DECL_NSIOFFLINECACHEUPDATEOBSERVER
+ NS_DECL_NSIRUNNABLE
+
+ nsOfflineCacheUpdate();
+
+ static nsresult GetCacheKey(nsIURI *aURI, nsACString &aKey);
+
+ nsresult Init();
+
+ nsresult Begin();
+
+ void LoadCompleted(nsOfflineCacheUpdateItem *aItem);
+ void ManifestCheckCompleted(nsresult aStatus,
+ const nsCString &aManifestHash);
+ void StickDocument(nsIURI *aDocumentURI);
+
+ void SetOwner(nsOfflineCacheUpdateOwner *aOwner);
+
+ bool IsForGroupID(const nsCSubstring &groupID);
+ bool IsForProfile(nsIFile* aCustomProfileDir);
+
+ virtual nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate) override;
+
+protected:
+ ~nsOfflineCacheUpdate();
+
+ friend class nsOfflineCacheUpdateItem;
+ void OnByteProgress(uint64_t byteIncrement);
+
+private:
+ nsresult InitInternal(nsIURI *aManifestURI, nsIPrincipal* aPrincipal);
+ nsresult HandleManifest(bool *aDoUpdate);
+ nsresult AddURI(nsIURI *aURI, uint32_t aItemType, uint32_t aLoadFlags = 0);
+
+ nsresult ProcessNextURI();
+
+ // Adds items from the previous cache witha type matching aType.
+ // If namespaceFilter is non-null, only items matching the
+ // specified namespaces will be added.
+ nsresult AddExistingItems(uint32_t aType,
+ nsTArray<nsCString>* namespaceFilter = nullptr);
+ nsresult ScheduleImplicit();
+ void AssociateDocuments(nsIApplicationCache* cache);
+ bool CheckUpdateAvailability();
+ void NotifyUpdateAvailability(bool updateAvailable);
+
+ void GatherObservers(nsCOMArray<nsIOfflineCacheUpdateObserver> &aObservers);
+ void NotifyState(uint32_t state);
+ nsresult Finish();
+ nsresult FinishNoNotify();
+
+ void AsyncFinishWithError();
+
+ // Find one non-pinned cache group and evict it.
+ nsresult EvictOneNonPinned();
+
+ enum {
+ STATE_UNINITIALIZED,
+ STATE_INITIALIZED,
+ STATE_CHECKING,
+ STATE_DOWNLOADING,
+ STATE_CANCELLED,
+ STATE_FINISHED
+ } mState;
+
+ mozilla::WeakPtr<nsOfflineCacheUpdateOwner> mOwner;
+
+ bool mAddedItems;
+ bool mPartialUpdate;
+ bool mOnlyCheckUpdate;
+ bool mSucceeded;
+ bool mObsolete;
+
+ nsCString mUpdateDomain;
+ nsCString mGroupID;
+ nsCOMPtr<nsIURI> mManifestURI;
+ nsCOMPtr<nsIURI> mDocumentURI;
+ nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
+ nsCOMPtr<nsIFile> mCustomProfileDir;
+
+ nsCOMPtr<nsIObserver> mUpdateAvailableObserver;
+
+ nsCOMPtr<nsIApplicationCache> mApplicationCache;
+ nsCOMPtr<nsIApplicationCache> mPreviousApplicationCache;
+
+ nsCOMPtr<nsIObserverService> mObserverService;
+
+ RefPtr<nsOfflineManifestItem> mManifestItem;
+
+ /* Items being updated */
+ uint32_t mItemsInProgress;
+ nsTArray<RefPtr<nsOfflineCacheUpdateItem> > mItems;
+
+ /* Clients watching this update for changes */
+ nsCOMArray<nsIWeakReference> mWeakObservers;
+ nsCOMArray<nsIOfflineCacheUpdateObserver> mObservers;
+
+ /* Documents that requested this update */
+ nsCOMArray<nsIURI> mDocumentURIs;
+
+ /* Reschedule count. When an update is rescheduled due to
+ * mismatched manifests, the reschedule count will be increased. */
+ uint32_t mRescheduleCount;
+
+ /* Whena an entry for a pinned app is retried, retries count is
+ * increaded. */
+ uint32_t mPinnedEntryRetriesCount;
+
+ RefPtr<nsOfflineCacheUpdate> mImplicitUpdate;
+
+ bool mPinned;
+
+ uint64_t mByteProgress;
+};
+
+class nsOfflineCacheUpdateService final : public nsIOfflineCacheUpdateService
+ , public nsIObserver
+ , public nsOfflineCacheUpdateOwner
+ , public nsSupportsWeakReference
+{
+public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOFFLINECACHEUPDATESERVICE
+ NS_DECL_NSIOBSERVER
+
+ nsOfflineCacheUpdateService();
+
+ nsresult Init();
+
+ nsresult ScheduleUpdate(nsOfflineCacheUpdate *aUpdate);
+ nsresult FindUpdate(nsIURI *aManifestURI,
+ nsACString const &aOriginSuffix,
+ nsIFile *aCustomProfileDir,
+ nsOfflineCacheUpdate **aUpdate);
+
+ nsresult Schedule(nsIURI *aManifestURI,
+ nsIURI *aDocumentURI,
+ nsIPrincipal* aLoadingPrincipal,
+ nsIDOMDocument *aDocument,
+ nsPIDOMWindowInner* aWindow,
+ nsIFile* aCustomProfileDir,
+ nsIOfflineCacheUpdate **aUpdate);
+
+ virtual nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate) override;
+
+ /**
+ * Returns the singleton nsOfflineCacheUpdateService without an addref, or
+ * nullptr if the service couldn't be created.
+ */
+ static nsOfflineCacheUpdateService *EnsureService();
+
+ /** Addrefs and returns the singleton nsOfflineCacheUpdateService. */
+ static nsOfflineCacheUpdateService *GetInstance();
+
+ static nsresult OfflineAppPinnedForURI(nsIURI *aDocumentURI,
+ nsIPrefBranch *aPrefBranch,
+ bool *aPinned);
+
+ static nsTHashtable<nsCStringHashKey>* AllowedDomains();
+
+private:
+ ~nsOfflineCacheUpdateService();
+
+ nsresult ProcessNextUpdate();
+
+ nsTArray<RefPtr<nsOfflineCacheUpdate> > mUpdates;
+ static nsTHashtable<nsCStringHashKey>* mAllowedDomains;
+
+ bool mDisabled;
+ bool mUpdateRunning;
+ bool mLowFreeSpace;
+};
+
+#endif