1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
5 * You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #include "ActorsChild.h"
10 #include "QuotaManagerService.h"
11 #include "QuotaRequests.h"
12 #include "QuotaResults.h"
17 #include "mozilla/Assertions.h"
18 #include "mozilla/dom/quota/PQuotaRequest.h"
19 #include "mozilla/dom/quota/PQuotaUsageRequest.h"
22 #include "nsIEventTarget.h"
23 #include "nsIQuotaResults.h"
24 #include "nsISupports.h"
25 #include "nsIVariant.h"
27 #include "nsThreadUtils.h"
28 #include "nsVariant.h"
30 namespace mozilla::dom::quota
{
32 /*******************************************************************************
34 ******************************************************************************/
36 QuotaChild::QuotaChild(QuotaManagerService
* aService
)
40 mOwningThread(GetCurrentSerialEventTarget())
43 AssertIsOnOwningThread();
46 MOZ_COUNT_CTOR(quota::QuotaChild
);
49 QuotaChild::~QuotaChild() {
50 AssertIsOnOwningThread();
52 MOZ_COUNT_DTOR(quota::QuotaChild
);
57 void QuotaChild::AssertIsOnOwningThread() const {
58 MOZ_ASSERT(mOwningThread
);
61 MOZ_ASSERT(NS_SUCCEEDED(mOwningThread
->IsOnCurrentThread(¤t
)));
67 void QuotaChild::ActorDestroy(ActorDestroyReason aWhy
) {
68 AssertIsOnOwningThread();
71 mService
->ClearBackgroundActor();
78 PQuotaUsageRequestChild
* QuotaChild::AllocPQuotaUsageRequestChild(
79 const UsageRequestParams
& aParams
) {
80 AssertIsOnOwningThread();
82 MOZ_CRASH("PQuotaUsageRequestChild actors should be manually constructed!");
85 bool QuotaChild::DeallocPQuotaUsageRequestChild(
86 PQuotaUsageRequestChild
* aActor
) {
87 AssertIsOnOwningThread();
90 delete static_cast<QuotaUsageRequestChild
*>(aActor
);
94 PQuotaRequestChild
* QuotaChild::AllocPQuotaRequestChild(
95 const RequestParams
& aParams
) {
96 AssertIsOnOwningThread();
98 MOZ_CRASH("PQuotaRequestChild actors should be manually constructed!");
101 bool QuotaChild::DeallocPQuotaRequestChild(PQuotaRequestChild
* aActor
) {
102 AssertIsOnOwningThread();
105 delete static_cast<QuotaRequestChild
*>(aActor
);
109 /*******************************************************************************
110 * QuotaUsageRequestChild
111 ******************************************************************************/
113 QuotaUsageRequestChild::QuotaUsageRequestChild(UsageRequest
* aRequest
)
114 : mRequest(aRequest
) {
115 AssertIsOnOwningThread();
117 MOZ_COUNT_CTOR(quota::QuotaUsageRequestChild
);
120 QuotaUsageRequestChild::~QuotaUsageRequestChild() {
121 // Can't assert owning thread here because the request is cleared.
123 MOZ_COUNT_DTOR(quota::QuotaUsageRequestChild
);
128 void QuotaUsageRequestChild::AssertIsOnOwningThread() const {
129 MOZ_ASSERT(mRequest
);
130 mRequest
->AssertIsOnOwningThread();
135 void QuotaUsageRequestChild::HandleResponse(nsresult aResponse
) {
136 AssertIsOnOwningThread();
137 MOZ_ASSERT(NS_FAILED(aResponse
));
138 MOZ_ASSERT(mRequest
);
140 mRequest
->SetError(aResponse
);
143 void QuotaUsageRequestChild::HandleResponse(
144 const nsTArray
<OriginUsage
>& aResponse
) {
145 AssertIsOnOwningThread();
146 MOZ_ASSERT(mRequest
);
148 RefPtr
<nsVariant
> variant
= new nsVariant();
150 if (aResponse
.IsEmpty()) {
151 variant
->SetAsEmptyArray();
153 nsTArray
<RefPtr
<UsageResult
>> usageResults(aResponse
.Length());
155 for (const auto& originUsage
: aResponse
) {
156 usageResults
.AppendElement(MakeRefPtr
<UsageResult
>(
157 originUsage
.origin(), originUsage
.persisted(), originUsage
.usage(),
158 originUsage
.lastAccessed()));
161 variant
->SetAsArray(nsIDataType::VTYPE_INTERFACE_IS
,
162 &NS_GET_IID(nsIQuotaUsageResult
), usageResults
.Length(),
163 static_cast<void*>(usageResults
.Elements()));
166 mRequest
->SetResult(variant
);
169 void QuotaUsageRequestChild::HandleResponse(
170 const OriginUsageResponse
& aResponse
) {
171 AssertIsOnOwningThread();
172 MOZ_ASSERT(mRequest
);
174 RefPtr
<OriginUsageResult
> result
=
175 new OriginUsageResult(aResponse
.usageInfo());
177 RefPtr
<nsVariant
> variant
= new nsVariant();
178 variant
->SetAsInterface(NS_GET_IID(nsIQuotaOriginUsageResult
), result
);
180 mRequest
->SetResult(variant
);
183 void QuotaUsageRequestChild::ActorDestroy(ActorDestroyReason aWhy
) {
184 AssertIsOnOwningThread();
187 mRequest
->ClearBackgroundActor();
194 mozilla::ipc::IPCResult
QuotaUsageRequestChild::Recv__delete__(
195 const UsageRequestResponse
& aResponse
) {
196 AssertIsOnOwningThread();
197 MOZ_ASSERT(mRequest
);
199 switch (aResponse
.type()) {
200 case UsageRequestResponse::Tnsresult
:
201 HandleResponse(aResponse
.get_nsresult());
204 case UsageRequestResponse::TAllUsageResponse
:
205 HandleResponse(aResponse
.get_AllUsageResponse().originUsages());
208 case UsageRequestResponse::TOriginUsageResponse
:
209 HandleResponse(aResponse
.get_OriginUsageResponse());
213 MOZ_CRASH("Unknown response type!");
219 /*******************************************************************************
221 ******************************************************************************/
223 QuotaRequestChild::QuotaRequestChild(Request
* aRequest
) : mRequest(aRequest
) {
224 AssertIsOnOwningThread();
226 MOZ_COUNT_CTOR(quota::QuotaRequestChild
);
229 QuotaRequestChild::~QuotaRequestChild() {
230 AssertIsOnOwningThread();
232 MOZ_COUNT_DTOR(quota::QuotaRequestChild
);
237 void QuotaRequestChild::AssertIsOnOwningThread() const {
238 MOZ_ASSERT(mRequest
);
239 mRequest
->AssertIsOnOwningThread();
244 void QuotaRequestChild::HandleResponse(nsresult aResponse
) {
245 AssertIsOnOwningThread();
246 MOZ_ASSERT(NS_FAILED(aResponse
));
247 MOZ_ASSERT(mRequest
);
249 mRequest
->SetError(aResponse
);
252 void QuotaRequestChild::HandleResponse() {
253 AssertIsOnOwningThread();
254 MOZ_ASSERT(mRequest
);
256 RefPtr
<nsVariant
> variant
= new nsVariant();
257 variant
->SetAsVoid();
259 mRequest
->SetResult(variant
);
262 void QuotaRequestChild::HandleResponse(bool aResponse
) {
263 AssertIsOnOwningThread();
264 MOZ_ASSERT(mRequest
);
266 RefPtr
<nsVariant
> variant
= new nsVariant();
267 variant
->SetAsBool(aResponse
);
269 mRequest
->SetResult(variant
);
272 void QuotaRequestChild::HandleResponse(const nsAString
& aResponse
) {
273 AssertIsOnOwningThread();
274 MOZ_ASSERT(mRequest
);
276 RefPtr
<nsVariant
> variant
= new nsVariant();
277 variant
->SetAsAString(aResponse
);
279 mRequest
->SetResult(variant
);
282 void QuotaRequestChild::HandleResponse(const EstimateResponse
& aResponse
) {
283 AssertIsOnOwningThread();
284 MOZ_ASSERT(mRequest
);
286 RefPtr
<EstimateResult
> result
=
287 new EstimateResult(aResponse
.usage(), aResponse
.limit());
289 RefPtr
<nsVariant
> variant
= new nsVariant();
290 variant
->SetAsInterface(NS_GET_IID(nsIQuotaEstimateResult
), result
);
292 mRequest
->SetResult(variant
);
295 void QuotaRequestChild::HandleResponse(const nsTArray
<nsCString
>& aResponse
) {
296 AssertIsOnOwningThread();
297 MOZ_ASSERT(mRequest
);
299 RefPtr
<nsVariant
> variant
= new nsVariant();
301 if (aResponse
.IsEmpty()) {
302 variant
->SetAsEmptyArray();
304 nsTArray
<const char*> stringPointers(aResponse
.Length());
305 std::transform(aResponse
.cbegin(), aResponse
.cend(),
306 MakeBackInserter(stringPointers
),
307 std::mem_fn(&nsCString::get
));
309 variant
->SetAsArray(nsIDataType::VTYPE_CHAR_STR
, nullptr,
310 stringPointers
.Length(), stringPointers
.Elements());
313 mRequest
->SetResult(variant
);
316 void QuotaRequestChild::HandleResponse(
317 const GetFullOriginMetadataResponse
& aResponse
) {
318 AssertIsOnOwningThread();
319 MOZ_ASSERT(mRequest
);
321 RefPtr
<nsVariant
> variant
= new nsVariant();
323 if (aResponse
.maybeFullOriginMetadata()) {
324 RefPtr
<FullOriginMetadataResult
> result
=
325 new FullOriginMetadataResult(*aResponse
.maybeFullOriginMetadata());
327 variant
->SetAsInterface(NS_GET_IID(nsIQuotaFullOriginMetadataResult
),
331 variant
->SetAsVoid();
334 mRequest
->SetResult(variant
);
337 void QuotaRequestChild::ActorDestroy(ActorDestroyReason aWhy
) {
338 AssertIsOnOwningThread();
341 mozilla::ipc::IPCResult
QuotaRequestChild::Recv__delete__(
342 const RequestResponse
& aResponse
) {
343 AssertIsOnOwningThread();
344 MOZ_ASSERT(mRequest
);
346 switch (aResponse
.type()) {
347 case RequestResponse::Tnsresult
:
348 HandleResponse(aResponse
.get_nsresult());
351 case RequestResponse::TStorageNameResponse
:
352 HandleResponse(aResponse
.get_StorageNameResponse().name());
355 case RequestResponse::TResetOriginResponse
:
356 case RequestResponse::TPersistResponse
:
360 case RequestResponse::TInitializePersistentOriginResponse
:
362 aResponse
.get_InitializePersistentOriginResponse().created());
365 case RequestResponse::TInitializeTemporaryOriginResponse
:
367 aResponse
.get_InitializeTemporaryOriginResponse().created());
370 case RequestResponse::TGetFullOriginMetadataResponse
:
371 HandleResponse(aResponse
.get_GetFullOriginMetadataResponse());
374 case RequestResponse::TPersistedResponse
:
375 HandleResponse(aResponse
.get_PersistedResponse().persisted());
378 case RequestResponse::TEstimateResponse
:
379 HandleResponse(aResponse
.get_EstimateResponse());
382 case RequestResponse::TListOriginsResponse
:
383 HandleResponse(aResponse
.get_ListOriginsResponse().origins());
387 MOZ_CRASH("Unknown response type!");
393 } // namespace mozilla::dom::quota