The Tor Browser: dom/devicestorage/DeviceStorageRequestParent.h@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* -*- Mode: C++; tab-width: 2; 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 file,

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

     6 #ifndef mozilla_dom_devicestorage_DeviceStorageRequestParent_h

     7 #define mozilla_dom_devicestorage_DeviceStorageRequestParent_h

     9 #include "mozilla/Attributes.h"

    10 #include "mozilla/dom/devicestorage/PDeviceStorageRequestParent.h"

    11 #include "mozilla/dom/ContentChild.h"

    12 #include "mozilla/dom/ContentParent.h"

    14 #include "nsThreadUtils.h"

    15 #include "nsDeviceStorage.h"

    16 #include "nsTArray.h"

    18 namespace mozilla {

    19 namespace dom {

    20 namespace devicestorage {

    22 class DeviceStorageRequestParent : public PDeviceStorageRequestParent

    23 {

    24 public:

    25   DeviceStorageRequestParent(const DeviceStorageParams& aParams);

    27   NS_IMETHOD_(MozExternalRefCountType) AddRef();

    28   NS_IMETHOD_(MozExternalRefCountType) Release();

    30   bool EnsureRequiredPermissions(mozilla::dom::ContentParent* aParent);

    31   void Dispatch();

    33   virtual void ActorDestroy(ActorDestroyReason);

    35 protected:

    36   ~DeviceStorageRequestParent();

    38 private:

    39   ThreadSafeAutoRefCnt mRefCnt;

    40   NS_DECL_OWNINGTHREAD

    41   DeviceStorageParams mParams;

    43   class CancelableRunnable : public nsRunnable

    44   {

    45   public:

    46     CancelableRunnable(DeviceStorageRequestParent* aParent)

    47       : mParent(aParent)

    48     {

    49       mCanceled = !(mParent->AddRunnable(this));

    50     }

    52     virtual ~CancelableRunnable() {

    53     }

    55     NS_IMETHOD Run() MOZ_OVERRIDE {

    56       nsresult rv = NS_OK;

    57       if (!mCanceled) {

    58         rv = CancelableRun();

    59         mParent->RemoveRunnable(this);

    60       }

    61       return rv;

    62     }

    64     void Cancel() {

    65       mCanceled = true;

    66     }

    68     virtual nsresult CancelableRun() = 0;

    70   protected:

    71     nsRefPtr<DeviceStorageRequestParent> mParent;

    72   private:

    73     bool mCanceled;

    74   };

    76   class PostErrorEvent : public CancelableRunnable

    77   {

    78     public:

    79       PostErrorEvent(DeviceStorageRequestParent* aParent, const char* aError);

    80       virtual ~PostErrorEvent();

    81       virtual nsresult CancelableRun();

    82     private:

    83       nsString mError;

    84   };

    86   class PostSuccessEvent : public CancelableRunnable

    87   {

    88     public:

    89       PostSuccessEvent(DeviceStorageRequestParent* aParent);

    90       virtual ~PostSuccessEvent();

    91       virtual nsresult CancelableRun();

    92   };

    94   class PostBlobSuccessEvent : public CancelableRunnable

    95   {

    96     public:

    97       PostBlobSuccessEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile, uint32_t aLength, nsACString& aMimeType, uint64_t aLastModifiedDate);

    98       virtual ~PostBlobSuccessEvent();

    99       virtual nsresult CancelableRun();

   100     private:

   101       uint32_t mLength;

   102       uint64_t mLastModificationDate;

   103       nsRefPtr<DeviceStorageFile> mFile;

   104       nsCString mMimeType;

   105   };

   107   class PostEnumerationSuccessEvent : public CancelableRunnable

   108   {

   109     public:

   110       PostEnumerationSuccessEvent(DeviceStorageRequestParent* aParent,

   111                                   const nsAString& aStorageType,

   112                                   const nsAString& aRelPath,

   113                                   InfallibleTArray<DeviceStorageFileValue>& aPaths);

   114       virtual ~PostEnumerationSuccessEvent();

   115       virtual nsresult CancelableRun();

   116     private:

   117       const nsString mStorageType;

   118       const nsString mRelPath;

   119       InfallibleTArray<DeviceStorageFileValue> mPaths;

   120   };

   122   class CreateFdEvent : public CancelableRunnable

   123   {

   124     public:

   125       CreateFdEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   126       virtual ~CreateFdEvent();

   127       virtual nsresult CancelableRun();

   128     private:

   129       nsRefPtr<DeviceStorageFile> mFile;

   130   };

   132   class WriteFileEvent : public CancelableRunnable

   133   {

   134     public:

   135       WriteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile, nsIInputStream* aInputStream);

   136       virtual ~WriteFileEvent();

   137       virtual nsresult CancelableRun();

   138     private:

   139       nsRefPtr<DeviceStorageFile> mFile;

   140       nsCOMPtr<nsIInputStream> mInputStream;

   141   };

   143   class DeleteFileEvent : public CancelableRunnable

   144   {

   145     public:

   146       DeleteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   147       virtual ~DeleteFileEvent();

   148       virtual nsresult CancelableRun();

   149     private:

   150       nsRefPtr<DeviceStorageFile> mFile;

   151   };

   153   class FreeSpaceFileEvent : public CancelableRunnable

   154   {

   155     public:

   156       FreeSpaceFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   157       virtual ~FreeSpaceFileEvent();

   158       virtual nsresult CancelableRun();

   159      private:

   160        nsRefPtr<DeviceStorageFile> mFile;

   161   };

   163   class UsedSpaceFileEvent : public CancelableRunnable

   164   {

   165     public:

   166       UsedSpaceFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   167       virtual ~UsedSpaceFileEvent();

   168       virtual nsresult CancelableRun();

   169      private:

   170        nsRefPtr<DeviceStorageFile> mFile;

   171   };

   173   class ReadFileEvent : public CancelableRunnable

   174   {

   175     public:

   176       ReadFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   177       virtual ~ReadFileEvent();

   178       virtual nsresult CancelableRun();

   179     private:

   180       nsRefPtr<DeviceStorageFile> mFile;

   181       nsCString mMimeType;

   182   };

   184   class EnumerateFileEvent : public CancelableRunnable

   185   {

   186     public:

   187       EnumerateFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile, uint64_t aSince);

   188       virtual ~EnumerateFileEvent();

   189       virtual nsresult CancelableRun();

   190     private:

   191       nsRefPtr<DeviceStorageFile> mFile;

   192       uint64_t mSince;

   193   };

   195   class PostPathResultEvent : public CancelableRunnable

   196   {

   197     public:

   198       PostPathResultEvent(DeviceStorageRequestParent* aParent, const nsAString& aPath);

   199       virtual ~PostPathResultEvent();

   200       virtual nsresult CancelableRun();

   201     private:

   202       nsRefPtr<DeviceStorageFile> mFile;

   203       nsString mPath;

   204   };

   206   class PostFileDescriptorResultEvent : public CancelableRunnable

   207   {

   208     public:

   209       PostFileDescriptorResultEvent(DeviceStorageRequestParent* aParent,

   210                                     const FileDescriptor& aFileDescriptor);

   211       virtual ~PostFileDescriptorResultEvent();

   212       virtual nsresult CancelableRun();

   213     private:

   214       nsRefPtr<DeviceStorageFile> mFile;

   215       FileDescriptor mFileDescriptor;

   216   };

   218  class PostFreeSpaceResultEvent : public CancelableRunnable

   219  {

   220     public:

   221       PostFreeSpaceResultEvent(DeviceStorageRequestParent* aParent,

   222                                uint64_t aFreeSpace);

   223       virtual ~PostFreeSpaceResultEvent();

   224       virtual nsresult CancelableRun();

   225     private:

   226       uint64_t mFreeSpace;

   227  };

   229  class PostUsedSpaceResultEvent : public CancelableRunnable

   230  {

   231     public:

   232       PostUsedSpaceResultEvent(DeviceStorageRequestParent* aParent,

   233                                const nsAString& aType,

   234                                uint64_t aUsedSpace);

   235       virtual ~PostUsedSpaceResultEvent();

   236       virtual nsresult CancelableRun();

   237     private:

   238       nsString mType;

   239       uint64_t mUsedSpace;

   240  };

   242  class PostAvailableResultEvent : public CancelableRunnable

   243  {

   244     public:

   245       PostAvailableResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   246       virtual ~PostAvailableResultEvent();

   247       virtual nsresult CancelableRun();

   248     private:

   249       nsRefPtr<DeviceStorageFile> mFile;

   250  };

   252  class PostStatusResultEvent : public CancelableRunnable

   253  {

   254     public:

   255       PostStatusResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   256       virtual ~PostStatusResultEvent();

   257       virtual nsresult CancelableRun();

   258     private:

   259       nsRefPtr<DeviceStorageFile> mFile;

   260  };

   262  class PostFormatResultEvent : public CancelableRunnable

   263  {

   264     public:

   265       PostFormatResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   266       virtual ~PostFormatResultEvent();

   267       virtual nsresult CancelableRun();

   268     private:

   269       nsRefPtr<DeviceStorageFile> mFile;

   270  };

   272  class PostMountResultEvent : public CancelableRunnable

   273  {

   274     public:

   275       PostMountResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   276       virtual ~PostMountResultEvent();

   277       virtual nsresult CancelableRun();

   278     private:

   279       nsRefPtr<DeviceStorageFile> mFile;

   280  };

   282  class PostUnmountResultEvent : public CancelableRunnable

   283  {

   284     public:

   285       PostUnmountResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);

   286       virtual ~PostUnmountResultEvent();

   287       virtual nsresult CancelableRun();

   288     private:

   289       nsRefPtr<DeviceStorageFile> mFile;

   290  };

   292 protected:

   293   bool AddRunnable(CancelableRunnable* aRunnable) {

   294     MutexAutoLock lock(mMutex);

   295     if (mActorDestoryed)

   296       return false;

   298     mRunnables.AppendElement(aRunnable);

   299     return true;

   300   }

   302   void RemoveRunnable(CancelableRunnable* aRunnable) {

   303     MutexAutoLock lock(mMutex);

   304     mRunnables.RemoveElement(aRunnable);

   305   }

   307   Mutex mMutex;

   308   bool mActorDestoryed;

   309   nsTArray<nsRefPtr<CancelableRunnable> > mRunnables;

   310 };

   312 } // namespace devicestorage

   313 } // namespace dom

   314 } // namespace mozilla

   316 #endif

The Tor Browser / file revision

dom/devicestorage/DeviceStorageRequestParent.h@129ffea94266

dom/devicestorage/DeviceStorageRequestParent.h