dom/devicestorage/DeviceStorageRequestParent.h

   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/. */
   5
   6 #ifndef mozilla_dom_devicestorage_DeviceStorageRequestParent_h
   7 #define mozilla_dom_devicestorage_DeviceStorageRequestParent_h
   8
   9 #include "mozilla/Attributes.h"
  10 #include "mozilla/dom/devicestorage/PDeviceStorageRequestParent.h"
  11 #include "mozilla/dom/ContentChild.h"
  12 #include "mozilla/dom/ContentParent.h"
  13
  14 #include "nsThreadUtils.h"
  15 #include "nsDeviceStorage.h"
  16 #include "nsTArray.h"
  17
  18 namespace mozilla {
  19 namespace dom {
  20 namespace devicestorage {
  21
  22 class DeviceStorageRequestParent : public PDeviceStorageRequestParent
  23 {
  24 public:
  25   DeviceStorageRequestParent(const DeviceStorageParams& aParams);
  26
  27   NS_IMETHOD_(nsrefcnt) AddRef();
  28   NS_IMETHOD_(nsrefcnt) Release();
  29
  30   bool EnsureRequiredPermissions(mozilla::dom::ContentParent* aParent);
  31   void Dispatch();
  32
  33   virtual void ActorDestroy(ActorDestroyReason);
  34
  35 protected:
  36   ~DeviceStorageRequestParent();
  37
  38 private:
  39   ThreadSafeAutoRefCnt mRefCnt;
  40   NS_DECL_OWNINGTHREAD
  41   DeviceStorageParams mParams;
  42
  43   class CancelableRunnable : public nsRunnable
  44   {
  45   public:
  46     CancelableRunnable(DeviceStorageRequestParent* aParent)
  47       : mParent(aParent)
  48     {
  49       mCanceled = !(mParent->AddRunnable(this));
  50     }
  51
  52     virtual ~CancelableRunnable() {
  53     }
  54
  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     }
  63
  64     void Cancel() {
  65       mCanceled = true;
  66     }
  67
  68     virtual nsresult CancelableRun() = 0;
  69
  70   protected:
  71     nsRefPtr<DeviceStorageRequestParent> mParent;
  72   private:
  73     bool mCanceled;
  74   };
  75
  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   };
  85
  86   class PostSuccessEvent : public CancelableRunnable
  87   {
  88     public:
  89       PostSuccessEvent(DeviceStorageRequestParent* aParent);
  90       virtual ~PostSuccessEvent();
  91       virtual nsresult CancelableRun();
  92   };
  93
  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   };
 106
 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   };
 121
 122   class WriteFileEvent : public CancelableRunnable
 123   {
 124     public:
 125       WriteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile, nsIInputStream* aInputStream);
 126       virtual ~WriteFileEvent();
 127       virtual nsresult CancelableRun();
 128     private:
 129       nsRefPtr<DeviceStorageFile> mFile;
 130       nsCOMPtr<nsIInputStream> mInputStream;
 131   };
 132
 133   class DeleteFileEvent : public CancelableRunnable
 134   {
 135     public:
 136       DeleteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 137       virtual ~DeleteFileEvent();
 138       virtual nsresult CancelableRun();
 139     private:
 140       nsRefPtr<DeviceStorageFile> mFile;
 141   };
 142
 143   class FreeSpaceFileEvent : public CancelableRunnable
 144   {
 145     public:
 146       FreeSpaceFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 147       virtual ~FreeSpaceFileEvent();
 148       virtual nsresult CancelableRun();
 149      private:
 150        nsRefPtr<DeviceStorageFile> mFile;
 151   };
 152
 153   class UsedSpaceFileEvent : public CancelableRunnable
 154   {
 155     public:
 156       UsedSpaceFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 157       virtual ~UsedSpaceFileEvent();
 158       virtual nsresult CancelableRun();
 159      private:
 160        nsRefPtr<DeviceStorageFile> mFile;
 161   };
 162
 163   class ReadFileEvent : public CancelableRunnable
 164   {
 165     public:
 166       ReadFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 167       virtual ~ReadFileEvent();
 168       virtual nsresult CancelableRun();
 169     private:
 170       nsRefPtr<DeviceStorageFile> mFile;
 171       nsCString mMimeType;
 172   };
 173
 174   class EnumerateFileEvent : public CancelableRunnable
 175   {
 176     public:
 177       EnumerateFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile, uint64_t aSince);
 178       virtual ~EnumerateFileEvent();
 179       virtual nsresult CancelableRun();
 180     private:
 181       nsRefPtr<DeviceStorageFile> mFile;
 182       uint64_t mSince;
 183   };
 184
 185   class PostPathResultEvent : public CancelableRunnable
 186   {
 187     public:
 188       PostPathResultEvent(DeviceStorageRequestParent* aParent, const nsAString& aPath);
 189       virtual ~PostPathResultEvent();
 190       virtual nsresult CancelableRun();
 191     private:
 192       nsRefPtr<DeviceStorageFile> mFile;
 193       nsString mPath;
 194   };
 195
 196  class PostFreeSpaceResultEvent : public CancelableRunnable
 197  {
 198     public:
 199       PostFreeSpaceResultEvent(DeviceStorageRequestParent* aParent,
 200                                uint64_t aFreeSpace);
 201       virtual ~PostFreeSpaceResultEvent();
 202       virtual nsresult CancelableRun();
 203     private:
 204       uint64_t mFreeSpace;
 205  };
 206
 207  class PostUsedSpaceResultEvent : public CancelableRunnable
 208  {
 209     public:
 210       PostUsedSpaceResultEvent(DeviceStorageRequestParent* aParent,
 211                                const nsAString& aType,
 212                                uint64_t aUsedSpace);
 213       virtual ~PostUsedSpaceResultEvent();
 214       virtual nsresult CancelableRun();
 215     private:
 216       nsString mType;
 217       uint64_t mUsedSpace;
 218  };
 219
 220  class PostAvailableResultEvent : public CancelableRunnable
 221  {
 222     public:
 223       PostAvailableResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 224       virtual ~PostAvailableResultEvent();
 225       virtual nsresult CancelableRun();
 226     private:
 227       nsRefPtr<DeviceStorageFile> mFile;
 228  };
 229
 230  class PostFormatResultEvent : public CancelableRunnable
 231  {
 232     public:
 233       PostFormatResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 234       virtual ~PostFormatResultEvent();
 235       virtual nsresult CancelableRun();
 236     private:
 237       nsRefPtr<DeviceStorageFile> mFile;
 238  };
 239
 240 protected:
 241   bool AddRunnable(CancelableRunnable* aRunnable) {
 242     MutexAutoLock lock(mMutex);
 243     if (mActorDestoryed)
 244       return false;
 245
 246     mRunnables.AppendElement(aRunnable);
 247     return true;
 248   }
 249
 250   void RemoveRunnable(CancelableRunnable* aRunnable) {
 251     MutexAutoLock lock(mMutex);
 252     mRunnables.RemoveElement(aRunnable);
 253   }
 254
 255   Mutex mMutex;
 256   bool mActorDestoryed;
 257   nsTArray<nsRefPtr<CancelableRunnable> > mRunnables;
 258 };
 259
 260 } // namespace devicestorage
 261 } // namespace dom
 262 } // namespace mozilla
 263
 264 #endif