From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../url-classifier/nsUrlClassifierProxies.h | 359 +++++++++++++++++++++ 1 file changed, 359 insertions(+) create mode 100644 toolkit/components/url-classifier/nsUrlClassifierProxies.h (limited to 'toolkit/components/url-classifier/nsUrlClassifierProxies.h') diff --git a/toolkit/components/url-classifier/nsUrlClassifierProxies.h b/toolkit/components/url-classifier/nsUrlClassifierProxies.h new file mode 100644 index 0000000000..5739d7bf21 --- /dev/null +++ b/toolkit/components/url-classifier/nsUrlClassifierProxies.h @@ -0,0 +1,359 @@ +/* -*- Mode: C++; tab-width: 8; 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 nsUrlClassifierProxies_h +#define nsUrlClassifierProxies_h + +#include "nsIUrlClassifierDBService.h" +#include "nsUrlClassifierDBService.h" +#include "nsProxyRelease.h" +#include "nsThreadUtils.h" +#include "mozilla/Attributes.h" +#include "nsIPrincipal.h" +#include "LookupCache.h" + +/** + * Thread proxy from the main thread to the worker thread. + */ +class UrlClassifierDBServiceWorkerProxy final + : public nsIUrlClassifierDBService { + public: + explicit UrlClassifierDBServiceWorkerProxy( + nsUrlClassifierDBServiceWorker* aTarget) + : mTarget(aTarget) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERDBSERVICE + + class LookupRunnable : public mozilla::Runnable { + public: + LookupRunnable(nsUrlClassifierDBServiceWorker* aTarget, + nsIPrincipal* aPrincipal, const nsACString& aTables, + nsIUrlClassifierCallback* aCB) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::LookupRunnable"), + mTarget(aTarget), + mPrincipal(aPrincipal), + mLookupTables(aTables), + mCB(aCB) {} + + NS_DECL_NSIRUNNABLE + + private: + const RefPtr mTarget; + const nsCOMPtr mPrincipal; + const nsCString mLookupTables; + const nsCOMPtr mCB; + }; + + class GetTablesRunnable : public mozilla::Runnable { + public: + GetTablesRunnable(nsUrlClassifierDBServiceWorker* aTarget, + nsIUrlClassifierCallback* aCB) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::GetTablesRunnable"), + mTarget(aTarget), + mCB(aCB) {} + + NS_DECL_NSIRUNNABLE + + private: + const RefPtr mTarget; + const nsCOMPtr mCB; + }; + + class BeginUpdateRunnable : public mozilla::Runnable { + public: + BeginUpdateRunnable(nsUrlClassifierDBServiceWorker* aTarget, + nsIUrlClassifierUpdateObserver* aUpdater, + const nsACString& aTables) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::BeginUpdateRunnable"), + mTarget(aTarget), + mUpdater(aUpdater), + mTables(aTables) {} + + NS_DECL_NSIRUNNABLE + + private: + const RefPtr mTarget; + const nsCOMPtr mUpdater; + const nsCString mTables; + }; + + class BeginStreamRunnable : public mozilla::Runnable { + public: + BeginStreamRunnable(nsUrlClassifierDBServiceWorker* aTarget, + const nsACString& aTable) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::BeginStreamRunnable"), + mTarget(aTarget), + mTable(aTable) {} + + NS_DECL_NSIRUNNABLE + + private: + const RefPtr mTarget; + const nsCString mTable; + }; + + class UpdateStreamRunnable : public mozilla::Runnable { + public: + UpdateStreamRunnable(nsUrlClassifierDBServiceWorker* aTarget, + const nsACString& aUpdateChunk) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::UpdateStreamRunnable"), + mTarget(aTarget), + mUpdateChunk(aUpdateChunk) {} + + NS_DECL_NSIRUNNABLE + + private: + const RefPtr mTarget; + const nsCString mUpdateChunk; + }; + + class CacheCompletionsRunnable : public mozilla::Runnable { + public: + CacheCompletionsRunnable( + nsUrlClassifierDBServiceWorker* aTarget, + const mozilla::safebrowsing::ConstCacheResultArray& aEntries) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::CacheCompletionsRunnable"), + mTarget(aTarget), + mEntries(aEntries.Clone()) {} + + NS_DECL_NSIRUNNABLE + + private: + const RefPtr mTarget; + const mozilla::safebrowsing::ConstCacheResultArray mEntries; + }; + + class ClearLastResultsRunnable : public mozilla::Runnable { + public: + explicit ClearLastResultsRunnable(nsUrlClassifierDBServiceWorker* aTarget) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::ClearLastResultsRunnable"), + mTarget(aTarget) {} + + NS_DECL_NSIRUNNABLE + private: + const RefPtr mTarget; + }; + + class GetCacheInfoRunnable : public mozilla::Runnable { + public: + explicit GetCacheInfoRunnable(nsUrlClassifierDBServiceWorker* aTarget, + const nsACString& aTable, + nsIUrlClassifierGetCacheCallback* aCallback) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::GetCacheInfoRunnable"), + mTarget(aTarget), + mTable(aTable), + mCache(nullptr), + mCallback(new nsMainThreadPtrHolder( + "nsIUrlClassifierGetCacheCallback", aCallback)) {} + + NS_DECL_NSIRUNNABLE + private: + const RefPtr mTarget; + const nsCString mTable; + nsCOMPtr mCache; + const nsMainThreadPtrHandle mCallback; + }; + + class GetCacheInfoCallbackRunnable : public mozilla::Runnable { + public: + explicit GetCacheInfoCallbackRunnable( + nsIUrlClassifierCacheInfo* aCache, + const nsMainThreadPtrHandle& + aCallback) + : mozilla::Runnable( + "UrlClassifierDBServiceWorkerProxy::" + "GetCacheInfoCallbackRunnable"), + mCache(aCache), + mCallback(aCallback) {} + + NS_DECL_NSIRUNNABLE + private: + nsCOMPtr mCache; + const nsMainThreadPtrHandle mCallback; + }; + + public: + nsresult OpenDb() const; + nsresult CloseDb() const; + nsresult PreShutdown() const; + + nsresult CacheCompletions( + const mozilla::safebrowsing::ConstCacheResultArray& aEntries) const; + + nsresult GetCacheInfo(const nsACString& aTable, + nsIUrlClassifierGetCacheCallback* aCallback) const; + + private: + ~UrlClassifierDBServiceWorkerProxy() = default; + + const RefPtr mTarget; +}; + +// The remaining classes here are all proxies to the main thread + +class UrlClassifierLookupCallbackProxy final + : public nsIUrlClassifierLookupCallback { + public: + explicit UrlClassifierLookupCallbackProxy( + nsIUrlClassifierLookupCallback* aTarget) + : mTarget(new nsMainThreadPtrHolder( + "UrlClassifierLookupCallbackProxy::mTarget", aTarget)) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERLOOKUPCALLBACK + + class LookupCompleteRunnable : public mozilla::Runnable { + public: + LookupCompleteRunnable( + const nsMainThreadPtrHandle& aTarget, + mozilla::UniquePtr aResults) + : mozilla::Runnable( + "UrlClassifierLookupCallbackProxy::LookupCompleteRunnable"), + mTarget(aTarget), + mResults(std::move(aResults)) {} + + NS_DECL_NSIRUNNABLE + + private: + const nsMainThreadPtrHandle mTarget; + mozilla::UniquePtr mResults; + }; + + private: + ~UrlClassifierLookupCallbackProxy() = default; + + const nsMainThreadPtrHandle mTarget; +}; + +class UrlClassifierCallbackProxy final : public nsIUrlClassifierCallback { + public: + explicit UrlClassifierCallbackProxy(nsIUrlClassifierCallback* aTarget) + : mTarget(new nsMainThreadPtrHolder( + "UrlClassifierCallbackProxy::mTarget", aTarget)) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERCALLBACK + + class HandleEventRunnable : public mozilla::Runnable { + public: + HandleEventRunnable( + const nsMainThreadPtrHandle& aTarget, + const nsACString& aValue) + : mozilla::Runnable("UrlClassifierCallbackProxy::HandleEventRunnable"), + mTarget(aTarget), + mValue(aValue) {} + + NS_DECL_NSIRUNNABLE + + private: + const nsMainThreadPtrHandle mTarget; + const nsCString mValue; + }; + + private: + ~UrlClassifierCallbackProxy() = default; + + const nsMainThreadPtrHandle mTarget; +}; + +class UrlClassifierUpdateObserverProxy final + : public nsIUrlClassifierUpdateObserver { + public: + explicit UrlClassifierUpdateObserverProxy( + nsIUrlClassifierUpdateObserver* aTarget) + : mTarget(new nsMainThreadPtrHolder( + "UrlClassifierUpdateObserverProxy::mTarget", aTarget)) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERUPDATEOBSERVER + + class UpdateUrlRequestedRunnable : public mozilla::Runnable { + public: + UpdateUrlRequestedRunnable( + const nsMainThreadPtrHandle& aTarget, + const nsACString& aURL, const nsACString& aTable) + : mozilla::Runnable( + "UrlClassifierUpdateObserverProxy::UpdateUrlRequestedRunnable"), + mTarget(aTarget), + mURL(aURL), + mTable(aTable) {} + + NS_DECL_NSIRUNNABLE + + private: + const nsMainThreadPtrHandle mTarget; + const nsCString mURL; + const nsCString mTable; + }; + + class StreamFinishedRunnable : public mozilla::Runnable { + public: + StreamFinishedRunnable( + const nsMainThreadPtrHandle& aTarget, + nsresult aStatus, uint32_t aDelay) + : mozilla::Runnable( + "UrlClassifierUpdateObserverProxy::StreamFinishedRunnable"), + mTarget(aTarget), + mStatus(aStatus), + mDelay(aDelay) {} + + NS_DECL_NSIRUNNABLE + + private: + const nsMainThreadPtrHandle mTarget; + const nsresult mStatus; + const uint32_t mDelay; + }; + + class UpdateErrorRunnable : public mozilla::Runnable { + public: + UpdateErrorRunnable( + const nsMainThreadPtrHandle& aTarget, + nsresult aError) + : mozilla::Runnable( + "UrlClassifierUpdateObserverProxy::UpdateErrorRunnable"), + mTarget(aTarget), + mError(aError) {} + + NS_DECL_NSIRUNNABLE + + private: + const nsMainThreadPtrHandle mTarget; + const nsresult mError; + }; + + class UpdateSuccessRunnable : public mozilla::Runnable { + public: + UpdateSuccessRunnable( + const nsMainThreadPtrHandle& aTarget, + uint32_t aRequestedTimeout) + : mozilla::Runnable( + "UrlClassifierUpdateObserverProxy::UpdateSuccessRunnable"), + mTarget(aTarget), + mRequestedTimeout(aRequestedTimeout) {} + + NS_DECL_NSIRUNNABLE + + private: + const nsMainThreadPtrHandle mTarget; + const uint32_t mRequestedTimeout; + }; + + private: + ~UrlClassifierUpdateObserverProxy() = default; + + const nsMainThreadPtrHandle mTarget; +}; + +#endif // nsUrlClassifierProxies_h -- cgit v1.2.3