dom/quota/ActorsChild.cpp

   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/. */
   6
   7 #include "ActorsChild.h"
   8
   9 // Local includes
  10 #include "QuotaManagerService.h"
  11 #include "QuotaRequests.h"
  12 #include "QuotaResults.h"
  13
  14 // Global includes
  15 #include <new>
  16 #include <utility>
  17 #include "mozilla/Assertions.h"
  18 #include "mozilla/dom/quota/PQuotaRequest.h"
  19 #include "mozilla/dom/quota/PQuotaUsageRequest.h"
  20 #include "nsError.h"
  21 #include "nsID.h"
  22 #include "nsIEventTarget.h"
  23 #include "nsIQuotaResults.h"
  24 #include "nsISupports.h"
  25 #include "nsIVariant.h"
  26 #include "nsString.h"
  27 #include "nsThreadUtils.h"
  28 #include "nsVariant.h"
  29
  30 namespace mozilla::dom::quota {
  31
  32 /*******************************************************************************
  33  * QuotaChild
  34  ******************************************************************************/
  35
  36 QuotaChild::QuotaChild(QuotaManagerService* aService)
  37     : mService(aService)
  38 #ifdef DEBUG
  39       ,
  40       mOwningThread(GetCurrentSerialEventTarget())
  41 #endif
  42 {
  43   AssertIsOnOwningThread();
  44   MOZ_ASSERT(aService);
  45
  46   MOZ_COUNT_CTOR(quota::QuotaChild);
  47 }
  48
  49 QuotaChild::~QuotaChild() {
  50   AssertIsOnOwningThread();
  51
  52   MOZ_COUNT_DTOR(quota::QuotaChild);
  53 }
  54
  55 #ifdef DEBUG
  56
  57 void QuotaChild::AssertIsOnOwningThread() const {
  58   MOZ_ASSERT(mOwningThread);
  59
  60   bool current;
  61   MOZ_ASSERT(NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)));
  62   MOZ_ASSERT(current);
  63 }
  64
  65 #endif  // DEBUG
  66
  67 void QuotaChild::ActorDestroy(ActorDestroyReason aWhy) {
  68   AssertIsOnOwningThread();
  69
  70   if (mService) {
  71     mService->ClearBackgroundActor();
  72 #ifdef DEBUG
  73     mService = nullptr;
  74 #endif
  75   }
  76 }
  77
  78 PQuotaUsageRequestChild* QuotaChild::AllocPQuotaUsageRequestChild(
  79     const UsageRequestParams& aParams) {
  80   AssertIsOnOwningThread();
  81
  82   MOZ_CRASH("PQuotaUsageRequestChild actors should be manually constructed!");
  83 }
  84
  85 bool QuotaChild::DeallocPQuotaUsageRequestChild(
  86     PQuotaUsageRequestChild* aActor) {
  87   AssertIsOnOwningThread();
  88   MOZ_ASSERT(aActor);
  89
  90   delete static_cast<QuotaUsageRequestChild*>(aActor);
  91   return true;
  92 }
  93
  94 PQuotaRequestChild* QuotaChild::AllocPQuotaRequestChild(
  95     const RequestParams& aParams) {
  96   AssertIsOnOwningThread();
  97
  98   MOZ_CRASH("PQuotaRequestChild actors should be manually constructed!");
  99 }
 100
 101 bool QuotaChild::DeallocPQuotaRequestChild(PQuotaRequestChild* aActor) {
 102   AssertIsOnOwningThread();
 103   MOZ_ASSERT(aActor);
 104
 105   delete static_cast<QuotaRequestChild*>(aActor);
 106   return true;
 107 }
 108
 109 /*******************************************************************************
 110  * QuotaUsageRequestChild
 111  ******************************************************************************/
 112
 113 QuotaUsageRequestChild::QuotaUsageRequestChild(UsageRequest* aRequest)
 114     : mRequest(aRequest) {
 115   AssertIsOnOwningThread();
 116
 117   MOZ_COUNT_CTOR(quota::QuotaUsageRequestChild);
 118 }
 119
 120 QuotaUsageRequestChild::~QuotaUsageRequestChild() {
 121   // Can't assert owning thread here because the request is cleared.
 122
 123   MOZ_COUNT_DTOR(quota::QuotaUsageRequestChild);
 124 }
 125
 126 #ifdef DEBUG
 127
 128 void QuotaUsageRequestChild::AssertIsOnOwningThread() const {
 129   MOZ_ASSERT(mRequest);
 130   mRequest->AssertIsOnOwningThread();
 131 }
 132
 133 #endif  // DEBUG
 134
 135 void QuotaUsageRequestChild::HandleResponse(nsresult aResponse) {
 136   AssertIsOnOwningThread();
 137   MOZ_ASSERT(NS_FAILED(aResponse));
 138   MOZ_ASSERT(mRequest);
 139
 140   mRequest->SetError(aResponse);
 141 }
 142
 143 void QuotaUsageRequestChild::HandleResponse(
 144     const nsTArray<OriginUsage>& aResponse) {
 145   AssertIsOnOwningThread();
 146   MOZ_ASSERT(mRequest);
 147
 148   RefPtr<nsVariant> variant = new nsVariant();
 149
 150   if (aResponse.IsEmpty()) {
 151     variant->SetAsEmptyArray();
 152   } else {
 153     nsTArray<RefPtr<UsageResult>> usageResults(aResponse.Length());
 154
 155     for (const auto& originUsage : aResponse) {
 156       usageResults.AppendElement(MakeRefPtr<UsageResult>(
 157           originUsage.origin(), originUsage.persisted(), originUsage.usage(),
 158           originUsage.lastAccessed()));
 159     }
 160
 161     variant->SetAsArray(nsIDataType::VTYPE_INTERFACE_IS,
 162                         &NS_GET_IID(nsIQuotaUsageResult), usageResults.Length(),
 163                         static_cast<void*>(usageResults.Elements()));
 164   }
 165
 166   mRequest->SetResult(variant);
 167 }
 168
 169 void QuotaUsageRequestChild::HandleResponse(
 170     const OriginUsageResponse& aResponse) {
 171   AssertIsOnOwningThread();
 172   MOZ_ASSERT(mRequest);
 173
 174   RefPtr<OriginUsageResult> result =
 175       new OriginUsageResult(aResponse.usageInfo());
 176
 177   RefPtr<nsVariant> variant = new nsVariant();
 178   variant->SetAsInterface(NS_GET_IID(nsIQuotaOriginUsageResult), result);
 179
 180   mRequest->SetResult(variant);
 181 }
 182
 183 void QuotaUsageRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
 184   AssertIsOnOwningThread();
 185
 186   if (mRequest) {
 187     mRequest->ClearBackgroundActor();
 188 #ifdef DEBUG
 189     mRequest = nullptr;
 190 #endif
 191   }
 192 }
 193
 194 mozilla::ipc::IPCResult QuotaUsageRequestChild::Recv__delete__(
 195     const UsageRequestResponse& aResponse) {
 196   AssertIsOnOwningThread();
 197   MOZ_ASSERT(mRequest);
 198
 199   switch (aResponse.type()) {
 200     case UsageRequestResponse::Tnsresult:
 201       HandleResponse(aResponse.get_nsresult());
 202       break;
 203
 204     case UsageRequestResponse::TAllUsageResponse:
 205       HandleResponse(aResponse.get_AllUsageResponse().originUsages());
 206       break;
 207
 208     case UsageRequestResponse::TOriginUsageResponse:
 209       HandleResponse(aResponse.get_OriginUsageResponse());
 210       break;
 211
 212     default:
 213       MOZ_CRASH("Unknown response type!");
 214   }
 215
 216   return IPC_OK();
 217 }
 218
 219 /*******************************************************************************
 220  * QuotaRequestChild
 221  ******************************************************************************/
 222
 223 QuotaRequestChild::QuotaRequestChild(Request* aRequest) : mRequest(aRequest) {
 224   AssertIsOnOwningThread();
 225
 226   MOZ_COUNT_CTOR(quota::QuotaRequestChild);
 227 }
 228
 229 QuotaRequestChild::~QuotaRequestChild() {
 230   AssertIsOnOwningThread();
 231
 232   MOZ_COUNT_DTOR(quota::QuotaRequestChild);
 233 }
 234
 235 #ifdef DEBUG
 236
 237 void QuotaRequestChild::AssertIsOnOwningThread() const {
 238   MOZ_ASSERT(mRequest);
 239   mRequest->AssertIsOnOwningThread();
 240 }
 241
 242 #endif  // DEBUG
 243
 244 void QuotaRequestChild::HandleResponse(nsresult aResponse) {
 245   AssertIsOnOwningThread();
 246   MOZ_ASSERT(NS_FAILED(aResponse));
 247   MOZ_ASSERT(mRequest);
 248
 249   mRequest->SetError(aResponse);
 250 }
 251
 252 void QuotaRequestChild::HandleResponse() {
 253   AssertIsOnOwningThread();
 254   MOZ_ASSERT(mRequest);
 255
 256   RefPtr<nsVariant> variant = new nsVariant();
 257   variant->SetAsVoid();
 258
 259   mRequest->SetResult(variant);
 260 }
 261
 262 void QuotaRequestChild::HandleResponse(bool aResponse) {
 263   AssertIsOnOwningThread();
 264   MOZ_ASSERT(mRequest);
 265
 266   RefPtr<nsVariant> variant = new nsVariant();
 267   variant->SetAsBool(aResponse);
 268
 269   mRequest->SetResult(variant);
 270 }
 271
 272 void QuotaRequestChild::HandleResponse(const nsAString& aResponse) {
 273   AssertIsOnOwningThread();
 274   MOZ_ASSERT(mRequest);
 275
 276   RefPtr<nsVariant> variant = new nsVariant();
 277   variant->SetAsAString(aResponse);
 278
 279   mRequest->SetResult(variant);
 280 }
 281
 282 void QuotaRequestChild::HandleResponse(const EstimateResponse& aResponse) {
 283   AssertIsOnOwningThread();
 284   MOZ_ASSERT(mRequest);
 285
 286   RefPtr<EstimateResult> result =
 287       new EstimateResult(aResponse.usage(), aResponse.limit());
 288
 289   RefPtr<nsVariant> variant = new nsVariant();
 290   variant->SetAsInterface(NS_GET_IID(nsIQuotaEstimateResult), result);
 291
 292   mRequest->SetResult(variant);
 293 }
 294
 295 void QuotaRequestChild::HandleResponse(const nsTArray<nsCString>& aResponse) {
 296   AssertIsOnOwningThread();
 297   MOZ_ASSERT(mRequest);
 298
 299   RefPtr<nsVariant> variant = new nsVariant();
 300
 301   if (aResponse.IsEmpty()) {
 302     variant->SetAsEmptyArray();
 303   } else {
 304     nsTArray<const char*> stringPointers(aResponse.Length());
 305     std::transform(aResponse.cbegin(), aResponse.cend(),
 306                    MakeBackInserter(stringPointers),
 307                    std::mem_fn(&nsCString::get));
 308
 309     variant->SetAsArray(nsIDataType::VTYPE_CHAR_STR, nullptr,
 310                         stringPointers.Length(), stringPointers.Elements());
 311   }
 312
 313   mRequest->SetResult(variant);
 314 }
 315
 316 void QuotaRequestChild::HandleResponse(
 317     const GetFullOriginMetadataResponse& aResponse) {
 318   AssertIsOnOwningThread();
 319   MOZ_ASSERT(mRequest);
 320
 321   RefPtr<nsVariant> variant = new nsVariant();
 322
 323   if (aResponse.maybeFullOriginMetadata()) {
 324     RefPtr<FullOriginMetadataResult> result =
 325         new FullOriginMetadataResult(*aResponse.maybeFullOriginMetadata());
 326
 327     variant->SetAsInterface(NS_GET_IID(nsIQuotaFullOriginMetadataResult),
 328                             result);
 329
 330   } else {
 331     variant->SetAsVoid();
 332   }
 333
 334   mRequest->SetResult(variant);
 335 }
 336
 337 void QuotaRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
 338   AssertIsOnOwningThread();
 339 }
 340
 341 mozilla::ipc::IPCResult QuotaRequestChild::Recv__delete__(
 342     const RequestResponse& aResponse) {
 343   AssertIsOnOwningThread();
 344   MOZ_ASSERT(mRequest);
 345
 346   switch (aResponse.type()) {
 347     case RequestResponse::Tnsresult:
 348       HandleResponse(aResponse.get_nsresult());
 349       break;
 350
 351     case RequestResponse::TStorageNameResponse:
 352       HandleResponse(aResponse.get_StorageNameResponse().name());
 353       break;
 354
 355     case RequestResponse::TResetOriginResponse:
 356     case RequestResponse::TPersistResponse:
 357       HandleResponse();
 358       break;
 359
 360     case RequestResponse::TInitializePersistentOriginResponse:
 361       HandleResponse(
 362           aResponse.get_InitializePersistentOriginResponse().created());
 363       break;
 364
 365     case RequestResponse::TInitializeTemporaryOriginResponse:
 366       HandleResponse(
 367           aResponse.get_InitializeTemporaryOriginResponse().created());
 368       break;
 369
 370     case RequestResponse::TGetFullOriginMetadataResponse:
 371       HandleResponse(aResponse.get_GetFullOriginMetadataResponse());
 372       break;
 373
 374     case RequestResponse::TPersistedResponse:
 375       HandleResponse(aResponse.get_PersistedResponse().persisted());
 376       break;
 377
 378     case RequestResponse::TEstimateResponse:
 379       HandleResponse(aResponse.get_EstimateResponse());
 380       break;
 381
 382     case RequestResponse::TListOriginsResponse:
 383       HandleResponse(aResponse.get_ListOriginsResponse().origins());
 384       break;
 385
 386     default:
 387       MOZ_CRASH("Unknown response type!");
 388   }
 389
 390   return IPC_OK();
 391 }
 392
 393 }  // namespace mozilla::dom::quota