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   explicit DeviceStorageRequestParent(const DeviceStorageParams& aParams);
  26
  27   NS_IMETHOD_(MozExternalRefCountType) AddRef();
  28   NS_IMETHOD_(MozExternalRefCountType) 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     explicit 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       explicit 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 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   };
 131
 132   class WriteFileEvent : public CancelableRunnable
 133   {
 134     public:
 135       WriteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile,
 136                      nsIInputStream* aInputStream, int32_t aRequestType);
 137       virtual ~WriteFileEvent();
 138       virtual nsresult CancelableRun();
 139     private:
 140       nsRefPtr<DeviceStorageFile> mFile;
 141       nsCOMPtr<nsIInputStream> mInputStream;
 142       int32_t mRequestType;
 143   };
 144
 145   class DeleteFileEvent : public CancelableRunnable
 146   {
 147     public:
 148       DeleteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 149       virtual ~DeleteFileEvent();
 150       virtual nsresult CancelableRun();
 151     private:
 152       nsRefPtr<DeviceStorageFile> mFile;
 153   };
 154
 155   class FreeSpaceFileEvent : public CancelableRunnable
 156   {
 157     public:
 158       FreeSpaceFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 159       virtual ~FreeSpaceFileEvent();
 160       virtual nsresult CancelableRun();
 161      private:
 162        nsRefPtr<DeviceStorageFile> mFile;
 163   };
 164
 165   class UsedSpaceFileEvent : public CancelableRunnable
 166   {
 167     public:
 168       UsedSpaceFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 169       virtual ~UsedSpaceFileEvent();
 170       virtual nsresult CancelableRun();
 171      private:
 172        nsRefPtr<DeviceStorageFile> mFile;
 173   };
 174
 175   class ReadFileEvent : public CancelableRunnable
 176   {
 177     public:
 178       ReadFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 179       virtual ~ReadFileEvent();
 180       virtual nsresult CancelableRun();
 181     private:
 182       nsRefPtr<DeviceStorageFile> mFile;
 183       nsCString mMimeType;
 184   };
 185
 186   class EnumerateFileEvent : public CancelableRunnable
 187   {
 188     public:
 189       EnumerateFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile, uint64_t aSince);
 190       virtual ~EnumerateFileEvent();
 191       virtual nsresult CancelableRun();
 192     private:
 193       nsRefPtr<DeviceStorageFile> mFile;
 194       uint64_t mSince;
 195   };
 196
 197   class PostPathResultEvent : public CancelableRunnable
 198   {
 199     public:
 200       PostPathResultEvent(DeviceStorageRequestParent* aParent, const nsAString& aPath);
 201       virtual ~PostPathResultEvent();
 202       virtual nsresult CancelableRun();
 203     private:
 204       nsRefPtr<DeviceStorageFile> mFile;
 205       nsString mPath;
 206   };
 207
 208   class PostFileDescriptorResultEvent : public CancelableRunnable
 209   {
 210     public:
 211       PostFileDescriptorResultEvent(DeviceStorageRequestParent* aParent,
 212                                     const FileDescriptor& aFileDescriptor);
 213       virtual ~PostFileDescriptorResultEvent();
 214       virtual nsresult CancelableRun();
 215     private:
 216       nsRefPtr<DeviceStorageFile> mFile;
 217       FileDescriptor mFileDescriptor;
 218   };
 219
 220  class PostFreeSpaceResultEvent : public CancelableRunnable
 221  {
 222     public:
 223       PostFreeSpaceResultEvent(DeviceStorageRequestParent* aParent,
 224                                uint64_t aFreeSpace);
 225       virtual ~PostFreeSpaceResultEvent();
 226       virtual nsresult CancelableRun();
 227     private:
 228       uint64_t mFreeSpace;
 229  };
 230
 231  class PostUsedSpaceResultEvent : public CancelableRunnable
 232  {
 233     public:
 234       PostUsedSpaceResultEvent(DeviceStorageRequestParent* aParent,
 235                                const nsAString& aType,
 236                                uint64_t aUsedSpace);
 237       virtual ~PostUsedSpaceResultEvent();
 238       virtual nsresult CancelableRun();
 239     private:
 240       nsString mType;
 241       uint64_t mUsedSpace;
 242  };
 243
 244  class PostAvailableResultEvent : public CancelableRunnable
 245  {
 246     public:
 247       PostAvailableResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 248       virtual ~PostAvailableResultEvent();
 249       virtual nsresult CancelableRun();
 250     private:
 251       nsRefPtr<DeviceStorageFile> mFile;
 252  };
 253
 254  class PostStatusResultEvent : public CancelableRunnable
 255  {
 256     public:
 257       PostStatusResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 258       virtual ~PostStatusResultEvent();
 259       virtual nsresult CancelableRun();
 260     private:
 261       nsRefPtr<DeviceStorageFile> mFile;
 262  };
 263
 264  class PostFormatResultEvent : public CancelableRunnable
 265  {
 266     public:
 267       PostFormatResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 268       virtual ~PostFormatResultEvent();
 269       virtual nsresult CancelableRun();
 270     private:
 271       nsRefPtr<DeviceStorageFile> mFile;
 272  };
 273
 274  class PostMountResultEvent : public CancelableRunnable
 275  {
 276     public:
 277       PostMountResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 278       virtual ~PostMountResultEvent();
 279       virtual nsresult CancelableRun();
 280     private:
 281       nsRefPtr<DeviceStorageFile> mFile;
 282  };
 283
 284  class PostUnmountResultEvent : public CancelableRunnable
 285  {
 286     public:
 287       PostUnmountResultEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile);
 288       virtual ~PostUnmountResultEvent();
 289       virtual nsresult CancelableRun();
 290     private:
 291       nsRefPtr<DeviceStorageFile> mFile;
 292  };
 293
 294 protected:
 295   bool AddRunnable(CancelableRunnable* aRunnable) {
 296     MutexAutoLock lock(mMutex);
 297     if (mActorDestoryed)
 298       return false;
 299
 300     mRunnables.AppendElement(aRunnable);
 301     return true;
 302   }
 303
 304   void RemoveRunnable(CancelableRunnable* aRunnable) {
 305     MutexAutoLock lock(mMutex);
 306     mRunnables.RemoveElement(aRunnable);
 307   }
 308
 309   Mutex mMutex;
 310   bool mActorDestoryed;
 311   nsTArray<nsRefPtr<CancelableRunnable> > mRunnables;
 312 };
 313
 314 } // namespace devicestorage
 315 } // namespace dom
 316 } // namespace mozilla
 317
 318 #endif