The Tor Browser / file comparison

comparison: dom/devicestorage/DeviceStorageRequestParent.h

dom/devicestorage/DeviceStorageRequestParent.h

branch
TOR_BUG_9701
changeset 9
a63d609f5ebe
equal deleted inserted replaced
-1:000000000000 0:f01f9ff77f51
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_(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 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 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, nsIInputStream* aInputStream);
136 virtual ~WriteFileEvent();
137 virtual nsresult CancelableRun();
138 private:
139 nsRefPtr<DeviceStorageFile> mFile;
140 nsCOMPtr<nsIInputStream> mInputStream;
141 };
142
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 };
152
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 };
162
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 };
172
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 };
183
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 };
194
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 };
205
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 };
217
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 };
228
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 };
241
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 };
251
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 };
261
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 };
271
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 };
281
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 };
291
292 protected:
293 bool AddRunnable(CancelableRunnable* aRunnable) {
294 MutexAutoLock lock(mMutex);
295 if (mActorDestoryed)
296 return false;
297
298 mRunnables.AppendElement(aRunnable);
299 return true;
300 }
301
302 void RemoveRunnable(CancelableRunnable* aRunnable) {
303 MutexAutoLock lock(mMutex);
304 mRunnables.RemoveElement(aRunnable);
305 }
306
307 Mutex mMutex;
308 bool mActorDestoryed;
309 nsTArray<nsRefPtr<CancelableRunnable> > mRunnables;
310 };
311
312 } // namespace devicestorage
313 } // namespace dom
314 } // namespace mozilla
315
316 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial