The Tor Browser: toolkit/components/url-classifier/nsUrlClassifierProxies.h@925c144e1f1f

     1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #ifndef nsUrlClassifierProxies_h

     7 #define nsUrlClassifierProxies_h

     9 #include "nsIUrlClassifierDBService.h"

    10 #include "nsProxyRelease.h"

    11 #include "nsThreadUtils.h"

    12 #include "mozilla/Attributes.h"

    13 #include "nsIPrincipal.h"

    14 #include "LookupCache.h"

    17 /**

    18  * Thread proxy from the main thread to the worker thread.

    19  */

    20 class UrlClassifierDBServiceWorkerProxy MOZ_FINAL :

    21   public nsIUrlClassifierDBServiceWorker

    22 {

    23 public:

    24   UrlClassifierDBServiceWorkerProxy(nsIUrlClassifierDBServiceWorker* aTarget)

    25     : mTarget(aTarget)

    26   { }

    28   NS_DECL_THREADSAFE_ISUPPORTS

    29   NS_DECL_NSIURLCLASSIFIERDBSERVICE

    30   NS_DECL_NSIURLCLASSIFIERDBSERVICEWORKER

    32   class LookupRunnable : public nsRunnable

    33   {

    34   public:

    35     LookupRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

    36                    nsIPrincipal* aPrincipal,

    37                    const nsACString& aTables,

    38                    nsIUrlClassifierCallback* aCB)

    39       : mTarget(aTarget)

    40       , mPrincipal(aPrincipal)

    41       , mLookupTables(aTables)

    42       , mCB(aCB)

    43     { }

    45     NS_DECL_NSIRUNNABLE

    47   private:

    48     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

    49     nsCOMPtr<nsIPrincipal> mPrincipal;

    50     nsCString mLookupTables;

    51     nsCOMPtr<nsIUrlClassifierCallback> mCB;

    52   };

    54   class GetTablesRunnable : public nsRunnable

    55   {

    56   public:

    57     GetTablesRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

    58                       nsIUrlClassifierCallback* aCB)

    59       : mTarget(aTarget)

    60       , mCB(aCB)

    61     { }

    63     NS_DECL_NSIRUNNABLE

    65   private:

    66     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

    67     nsCOMPtr<nsIUrlClassifierCallback> mCB;

    68   };

    70   class BeginUpdateRunnable : public nsRunnable

    71   {

    72   public:

    73     BeginUpdateRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

    74                         nsIUrlClassifierUpdateObserver* aUpdater,

    75                         const nsACString& aTables)

    76       : mTarget(aTarget)

    77       , mUpdater(aUpdater)

    78       , mTables(aTables)

    79     { }

    81     NS_DECL_NSIRUNNABLE

    83   private:

    84     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

    85     nsCOMPtr<nsIUrlClassifierUpdateObserver> mUpdater;

    86     nsCString mTables;

    87   };

    89   class BeginStreamRunnable : public nsRunnable

    90   {

    91   public:

    92     BeginStreamRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

    93                         const nsACString& aTable)

    94       : mTarget(aTarget)

    95       , mTable(aTable)

    96     { }

    98     NS_DECL_NSIRUNNABLE

   100   private:

   101     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

   102     nsCString mTable;

   103   };

   105   class UpdateStreamRunnable : public nsRunnable

   106   {

   107   public:

   108     UpdateStreamRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

   109                          const nsACString& aUpdateChunk)

   110       : mTarget(aTarget)

   111       , mUpdateChunk(aUpdateChunk)

   112     { }

   114     NS_DECL_NSIRUNNABLE

   116   private:

   117     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

   118     nsCString mUpdateChunk;

   119   };

   121   class CacheCompletionsRunnable : public nsRunnable

   122   {

   123   public:

   124     CacheCompletionsRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

   125                              mozilla::safebrowsing::CacheResultArray *aEntries)

   126       : mTarget(aTarget)

   127       , mEntries(aEntries)

   128     { }

   130     NS_DECL_NSIRUNNABLE

   132   private:

   133     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

   134      mozilla::safebrowsing::CacheResultArray *mEntries;

   135   };

   137   class CacheMissesRunnable : public nsRunnable

   138   {

   139   public:

   140     CacheMissesRunnable(nsIUrlClassifierDBServiceWorker* aTarget,

   141                         mozilla::safebrowsing::PrefixArray *aEntries)

   142       : mTarget(aTarget)

   143       , mEntries(aEntries)

   144     { }

   146     NS_DECL_NSIRUNNABLE

   148   private:

   149     nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

   150     mozilla::safebrowsing::PrefixArray *mEntries;

   151   };

   153 private:

   154   nsCOMPtr<nsIUrlClassifierDBServiceWorker> mTarget;

   155 };

   157 // The remaining classes here are all proxies to the main thread

   159 class UrlClassifierLookupCallbackProxy MOZ_FINAL :

   160   public nsIUrlClassifierLookupCallback

   161 {

   162 public:

   163   UrlClassifierLookupCallbackProxy(nsIUrlClassifierLookupCallback* aTarget)

   164     : mTarget(new nsMainThreadPtrHolder<nsIUrlClassifierLookupCallback>(aTarget))

   165   { }

   167   NS_DECL_THREADSAFE_ISUPPORTS

   168   NS_DECL_NSIURLCLASSIFIERLOOKUPCALLBACK

   170   class LookupCompleteRunnable : public nsRunnable

   171   {

   172   public:

   173     LookupCompleteRunnable(const nsMainThreadPtrHandle<nsIUrlClassifierLookupCallback>& aTarget,

   174                            mozilla::safebrowsing::LookupResultArray *aResults)

   175       : mTarget(aTarget)

   176       , mResults(aResults)

   177     { }

   179     NS_DECL_NSIRUNNABLE

   181   private:

   182     nsMainThreadPtrHandle<nsIUrlClassifierLookupCallback> mTarget;

   183     mozilla::safebrowsing::LookupResultArray * mResults;

   184   };

   186 private:

   187   nsMainThreadPtrHandle<nsIUrlClassifierLookupCallback> mTarget;

   188 };

   190 class UrlClassifierCallbackProxy MOZ_FINAL : public nsIUrlClassifierCallback

   191 {

   192 public:

   193   UrlClassifierCallbackProxy(nsIUrlClassifierCallback* aTarget)

   194     : mTarget(new nsMainThreadPtrHolder<nsIUrlClassifierCallback>(aTarget))

   195   { }

   197   NS_DECL_THREADSAFE_ISUPPORTS

   198   NS_DECL_NSIURLCLASSIFIERCALLBACK

   200   class HandleEventRunnable : public nsRunnable

   201   {

   202   public:

   203     HandleEventRunnable(const nsMainThreadPtrHandle<nsIUrlClassifierCallback>& aTarget,

   204                         const nsACString& aValue)

   205       : mTarget(aTarget)

   206       , mValue(aValue)

   207     { }

   209     NS_DECL_NSIRUNNABLE

   211   private:

   212     nsMainThreadPtrHandle<nsIUrlClassifierCallback> mTarget;

   213     nsCString mValue;

   214   };

   216 private:

   217   nsMainThreadPtrHandle<nsIUrlClassifierCallback> mTarget;

   218 };

   220 class UrlClassifierUpdateObserverProxy MOZ_FINAL :

   221   public nsIUrlClassifierUpdateObserver

   222 {

   223 public:

   224   UrlClassifierUpdateObserverProxy(nsIUrlClassifierUpdateObserver* aTarget)

   225     : mTarget(new nsMainThreadPtrHolder<nsIUrlClassifierUpdateObserver>(aTarget))

   226   { }

   228   NS_DECL_THREADSAFE_ISUPPORTS

   229   NS_DECL_NSIURLCLASSIFIERUPDATEOBSERVER

   231   class UpdateUrlRequestedRunnable : public nsRunnable

   232   {

   233   public:

   234     UpdateUrlRequestedRunnable(const nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver>& aTarget,

   235                                const nsACString& aURL,

   236                                const nsACString& aTable)

   237       : mTarget(aTarget)

   238       , mURL(aURL)

   239       , mTable(aTable)

   240     { }

   242     NS_DECL_NSIRUNNABLE

   244   private:

   245     nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver> mTarget;

   246     nsCString mURL, mTable;

   247   };

   249   class StreamFinishedRunnable : public nsRunnable

   250   {

   251   public:

   252     StreamFinishedRunnable(const nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver>& aTarget,

   253                            nsresult aStatus, uint32_t aDelay)

   254       : mTarget(aTarget)

   255       , mStatus(aStatus)

   256       , mDelay(aDelay)

   257     { }

   259     NS_DECL_NSIRUNNABLE

   261   private:

   262     nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver> mTarget;

   263     nsresult mStatus;

   264     uint32_t mDelay;

   265   };

   267   class UpdateErrorRunnable : public nsRunnable

   268   {

   269   public:

   270     UpdateErrorRunnable(const nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver>& aTarget,

   271                         nsresult aError)

   272       : mTarget(aTarget)

   273       , mError(aError)

   274     { }

   276     NS_DECL_NSIRUNNABLE

   278   private:

   279     nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver> mTarget;

   280     nsresult mError;

   281   };

   283   class UpdateSuccessRunnable : public nsRunnable

   284   {

   285   public:

   286     UpdateSuccessRunnable(const nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver>& aTarget,

   287                           uint32_t aRequestedTimeout)

   288       : mTarget(aTarget)

   289       , mRequestedTimeout(aRequestedTimeout)

   290     { }

   292     NS_DECL_NSIRUNNABLE

   294   private:

   295     nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver> mTarget;

   296     uint32_t mRequestedTimeout;

   297   };

   299 private:

   300   nsMainThreadPtrHandle<nsIUrlClassifierUpdateObserver> mTarget;

   301 };

   303 #endif // nsUrlClassifierProxies_h

The Tor Browser / file revision

toolkit/components/url-classifier/nsUrlClassifierProxies.h@925c144e1f1f

toolkit/components/url-classifier/nsUrlClassifierProxies.h