Add m-esr52 at 52.6.0

1 files changed, 845 insertions, 0 deletions

diff --git a/dom/quota/QuotaManagerService.cpp b/dom/quota/QuotaManagerService.cpp
new file mode 100644
index 000000000..fb5f0f3a1
--- /dev/null
+++ b/dom/quota/QuotaManagerService.cpp
@@ -0,0 +1,845 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "QuotaManagerService.h"
+
+#include "ActorsChild.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Hal.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Unused.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+#include "nsIIdleService.h"
+#include "nsIIPCBackgroundChildCreateCallback.h"
+#include "nsIObserverService.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsXULAppAPI.h"
+#include "QuotaManager.h"
+#include "QuotaRequests.h"
+
+#define PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID "profile-before-change-qm"
+
+namespace mozilla {
+namespace dom {
+namespace quota {
+
+using namespace mozilla::ipc;
+
+namespace {
+
+// Preference that is used to enable testing features.
+const char kTestingPref[] = "dom.quotaManager.testing";
+
+const char kIdleServiceContractId[] = "@mozilla.org/widget/idleservice;1";
+
+// The number of seconds we will wait after receiving the idle-daily
+// notification before beginning maintenance.
+const uint32_t kIdleObserverTimeSec = 1;
+
+mozilla::StaticRefPtr<QuotaManagerService> gQuotaManagerService;
+
+mozilla::Atomic<bool> gInitialized(false);
+mozilla::Atomic<bool> gClosed(false);
+mozilla::Atomic<bool> gTestingMode(false);
+
+void
+TestingPrefChangedCallback(const char* aPrefName,
+                           void* aClosure)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!strcmp(aPrefName, kTestingPref));
+  MOZ_ASSERT(!aClosure);
+
+  gTestingMode = Preferences::GetBool(aPrefName);
+}
+
+class AbortOperationsRunnable final
+  : public Runnable
+{
+  ContentParentId mContentParentId;
+
+public:
+  explicit AbortOperationsRunnable(ContentParentId aContentParentId)
+    : mContentParentId(aContentParentId)
+  { }
+
+private:
+  NS_DECL_NSIRUNNABLE
+};
+
+} // namespace
+
+class QuotaManagerService::BackgroundCreateCallback final
+  : public nsIIPCBackgroundChildCreateCallback
+{
+  RefPtr<QuotaManagerService> mService;
+
+public:
+  explicit
+  BackgroundCreateCallback(QuotaManagerService* aService)
+    : mService(aService)
+  {
+    MOZ_ASSERT(aService);
+  }
+
+  NS_DECL_ISUPPORTS
+
+private:
+  ~BackgroundCreateCallback()
+  { }
+
+  NS_DECL_NSIIPCBACKGROUNDCHILDCREATECALLBACK
+};
+
+class QuotaManagerService::PendingRequestInfo
+{
+protected:
+  RefPtr<RequestBase> mRequest;
+
+public:
+  explicit PendingRequestInfo(RequestBase* aRequest)
+    : mRequest(aRequest)
+  { }
+
+  virtual ~PendingRequestInfo()
+  { }
+
+  RequestBase*
+  GetRequest() const
+  {
+    return mRequest;
+  }
+
+  virtual nsresult
+  InitiateRequest(QuotaChild* aActor) = 0;
+};
+
+class QuotaManagerService::UsageRequestInfo
+  : public PendingRequestInfo
+{
+  UsageRequestParams mParams;
+
+public:
+  UsageRequestInfo(UsageRequest* aRequest,
+                   const UsageRequestParams& aParams)
+    : PendingRequestInfo(aRequest)
+    , mParams(aParams)
+  {
+    MOZ_ASSERT(aRequest);
+    MOZ_ASSERT(aParams.type() != UsageRequestParams::T__None);
+  }
+
+  virtual nsresult
+  InitiateRequest(QuotaChild* aActor) override;
+};
+
+class QuotaManagerService::RequestInfo
+  : public PendingRequestInfo
+{
+  RequestParams mParams;
+
+public:
+  RequestInfo(Request* aRequest,
+              const RequestParams& aParams)
+    : PendingRequestInfo(aRequest)
+    , mParams(aParams)
+  {
+    MOZ_ASSERT(aRequest);
+    MOZ_ASSERT(aParams.type() != RequestParams::T__None);
+  }
+
+  virtual nsresult
+  InitiateRequest(QuotaChild* aActor) override;
+};
+
+class QuotaManagerService::IdleMaintenanceInfo
+  : public PendingRequestInfo
+{
+  const bool mStart;
+
+public:
+  explicit IdleMaintenanceInfo(bool aStart)
+    : PendingRequestInfo(nullptr)
+    , mStart(aStart)
+  { }
+
+  virtual nsresult
+  InitiateRequest(QuotaChild* aActor) override;
+};
+
+QuotaManagerService::QuotaManagerService()
+  : mBackgroundActor(nullptr)
+  , mBackgroundActorFailed(false)
+  , mIdleObserverRegistered(false)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+}
+
+QuotaManagerService::~QuotaManagerService()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mIdleObserverRegistered);
+}
+
+// static
+QuotaManagerService*
+QuotaManagerService::GetOrCreate()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (gClosed) {
+    MOZ_ASSERT(false, "Calling GetOrCreate() after shutdown!");
+    return nullptr;
+  }
+
+  if (!gQuotaManagerService) {
+    RefPtr<QuotaManagerService> instance(new QuotaManagerService());
+
+    nsresult rv = instance->Init();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return nullptr;
+    }
+
+    if (gInitialized.exchange(true)) {
+      MOZ_ASSERT(false, "Initialized more than once?!");
+    }
+
+    gQuotaManagerService = instance;
+
+    ClearOnShutdown(&gQuotaManagerService);
+  }
+
+  return gQuotaManagerService;
+}
+
+// static
+QuotaManagerService*
+QuotaManagerService::Get()
+{
+  // Does not return an owning reference.
+  return gQuotaManagerService;
+}
+
+// static
+QuotaManagerService*
+QuotaManagerService::FactoryCreate()
+{
+  // Returns a raw pointer that carries an owning reference! Lame, but the
+  // singleton factory macros force this.
+  QuotaManagerService* quotaManagerService = GetOrCreate();
+  NS_IF_ADDREF(quotaManagerService);
+  return quotaManagerService;
+}
+
+void
+QuotaManagerService::ClearBackgroundActor()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mBackgroundActor = nullptr;
+}
+
+void
+QuotaManagerService::NoteLiveManager(QuotaManager* aManager)
+{
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aManager);
+
+  mBackgroundThread = aManager->OwningThread();
+}
+
+void
+QuotaManagerService::NoteShuttingDownManager()
+{
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mBackgroundThread = nullptr;
+}
+
+void
+QuotaManagerService::AbortOperationsForProcess(ContentParentId aContentParentId)
+{
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mBackgroundThread) {
+    return;
+  }
+
+  RefPtr<AbortOperationsRunnable> runnable =
+    new AbortOperationsRunnable(aContentParentId);
+
+  MOZ_ALWAYS_SUCCEEDS(
+    mBackgroundThread->Dispatch(runnable, NS_DISPATCH_NORMAL));
+}
+
+nsresult
+QuotaManagerService::Init()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (XRE_IsParentProcess()) {
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    if (NS_WARN_IF(!observerService)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    nsresult rv =
+      observerService->AddObserver(this,
+                                   PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID,
+                                   false);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  Preferences::RegisterCallbackAndCall(TestingPrefChangedCallback,
+                                       kTestingPref);
+
+  return NS_OK;
+}
+
+void
+QuotaManagerService::Destroy()
+{
+  // Setting the closed flag prevents the service from being recreated.
+  // Don't set it though if there's no real instance created.
+  if (gInitialized && gClosed.exchange(true)) {
+    MOZ_ASSERT(false, "Shutdown more than once?!");
+  }
+
+  Preferences::UnregisterCallback(TestingPrefChangedCallback, kTestingPref);
+
+  delete this;
+}
+
+nsresult
+QuotaManagerService::InitiateRequest(nsAutoPtr<PendingRequestInfo>& aInfo)
+{
+  // Nothing can be done here if we have previously failed to create a
+  // background actor.
+  if (mBackgroundActorFailed) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!mBackgroundActor && mPendingRequests.IsEmpty()) {
+    if (PBackgroundChild* actor = BackgroundChild::GetForCurrentThread()) {
+      BackgroundActorCreated(actor);
+    } else {
+      // We need to start the sequence to create a background actor for this
+      // thread.
+      RefPtr<BackgroundCreateCallback> cb = new BackgroundCreateCallback(this);
+      if (NS_WARN_IF(!BackgroundChild::GetOrCreateForCurrentThread(cb))) {
+        return NS_ERROR_FAILURE;
+      }
+    }
+  }
+
+  // If we already have a background actor then we can start this request now.
+  if (mBackgroundActor) {
+    nsresult rv = aInfo->InitiateRequest(mBackgroundActor);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  } else {
+    mPendingRequests.AppendElement(aInfo.forget());
+  }
+
+  return NS_OK;
+}
+
+nsresult
+QuotaManagerService::BackgroundActorCreated(PBackgroundChild* aBackgroundActor)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aBackgroundActor);
+  MOZ_ASSERT(!mBackgroundActor);
+  MOZ_ASSERT(!mBackgroundActorFailed);
+
+  {
+    QuotaChild* actor = new QuotaChild(this);
+
+    mBackgroundActor =
+      static_cast<QuotaChild*>(aBackgroundActor->SendPQuotaConstructor(actor));
+  }
+
+  if (NS_WARN_IF(!mBackgroundActor)) {
+    BackgroundActorFailed();
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv = NS_OK;
+
+  for (uint32_t index = 0, count = mPendingRequests.Length();
+       index < count;
+       index++) {
+    nsAutoPtr<PendingRequestInfo> info(mPendingRequests[index].forget());
+
+    nsresult rv2 = info->InitiateRequest(mBackgroundActor);
+
+    // Warn for every failure, but just return the first failure if there are
+    // multiple failures.
+    if (NS_WARN_IF(NS_FAILED(rv2)) && NS_SUCCEEDED(rv)) {
+      rv = rv2;
+    }
+  }
+
+  mPendingRequests.Clear();
+
+  return rv;
+}
+
+void
+QuotaManagerService::BackgroundActorFailed()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mPendingRequests.IsEmpty());
+  MOZ_ASSERT(!mBackgroundActor);
+  MOZ_ASSERT(!mBackgroundActorFailed);
+
+  mBackgroundActorFailed = true;
+
+  for (uint32_t index = 0, count = mPendingRequests.Length();
+       index < count;
+       index++) {
+    nsAutoPtr<PendingRequestInfo> info(mPendingRequests[index].forget());
+
+    RequestBase* request = info->GetRequest();
+    if (request) {
+      request->SetError(NS_ERROR_FAILURE);
+    }
+  }
+
+  mPendingRequests.Clear();
+}
+
+void
+QuotaManagerService::PerformIdleMaintenance()
+{
+  using namespace mozilla::hal;
+
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // If we're running on battery power then skip all idle maintenance since we
+  // would otherwise be doing lots of disk I/O.
+  BatteryInformation batteryInfo;
+
+#ifdef MOZ_WIDGET_ANDROID
+  // Android XPCShell doesn't load the AndroidBridge that is needed to make
+  // GetCurrentBatteryInformation work...
+  if (!QuotaManager::IsRunningXPCShellTests())
+#endif
+  {
+    GetCurrentBatteryInformation(&batteryInfo);
+  }
+
+  // If we're running XPCShell because we always want to be able to test this
+  // code so pretend that we're always charging.
+  if (QuotaManager::IsRunningXPCShellTests()) {
+    batteryInfo.level() = 100;
+    batteryInfo.charging() = true;
+  }
+
+  if (NS_WARN_IF(!batteryInfo.charging())) {
+    return;
+  }
+
+  if (QuotaManager::IsRunningXPCShellTests()) {
+    // We don't want user activity to impact this code if we're running tests.
+    Unused << Observe(nullptr, OBSERVER_TOPIC_IDLE, nullptr);
+  } else if (!mIdleObserverRegistered) {
+    nsCOMPtr<nsIIdleService> idleService =
+      do_GetService(kIdleServiceContractId);
+    MOZ_ASSERT(idleService);
+
+    MOZ_ALWAYS_SUCCEEDS(
+      idleService->AddIdleObserver(this, kIdleObserverTimeSec));
+
+    mIdleObserverRegistered = true;
+  }
+}
+
+void
+QuotaManagerService::RemoveIdleObserver()
+{
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mIdleObserverRegistered) {
+    nsCOMPtr<nsIIdleService> idleService =
+      do_GetService(kIdleServiceContractId);
+    MOZ_ASSERT(idleService);
+
+    MOZ_ALWAYS_SUCCEEDS(
+      idleService->RemoveIdleObserver(this, kIdleObserverTimeSec));
+
+    mIdleObserverRegistered = false;
+  }
+}
+
+NS_IMPL_ADDREF(QuotaManagerService)
+NS_IMPL_RELEASE_WITH_DESTROY(QuotaManagerService, Destroy())
+NS_IMPL_QUERY_INTERFACE(QuotaManagerService,
+                        nsIQuotaManagerService,
+                        nsIObserver)
+
+NS_IMETHODIMP
+QuotaManagerService::GetUsage(nsIQuotaUsageCallback* aCallback,
+                              bool aGetAll,
+                              nsIQuotaUsageRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aCallback);
+
+  RefPtr<UsageRequest> request = new UsageRequest(aCallback);
+
+  AllUsageParams params;
+
+  params.getAll() = aGetAll;
+
+  nsAutoPtr<PendingRequestInfo> info(new UsageRequestInfo(request, params));
+
+  nsresult rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotaManagerService::GetUsageForPrincipal(nsIPrincipal* aPrincipal,
+                                          nsIQuotaUsageCallback* aCallback,
+                                          bool aGetGroupUsage,
+                                          nsIQuotaUsageRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aPrincipal);
+  MOZ_ASSERT(aCallback);
+
+  RefPtr<UsageRequest> request = new UsageRequest(aPrincipal, aCallback);
+
+  OriginUsageParams params;
+
+  PrincipalInfo& principalInfo = params.principalInfo();
+  nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (principalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
+      principalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  params.getGroupUsage() = aGetGroupUsage;
+
+  nsAutoPtr<PendingRequestInfo> info(new UsageRequestInfo(request, params));
+
+  rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotaManagerService::Clear(nsIQuotaRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(nsContentUtils::IsCallerChrome());
+
+  if (NS_WARN_IF(!gTestingMode)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  RefPtr<Request> request = new Request();
+
+  ClearAllParams params;
+
+  nsAutoPtr<PendingRequestInfo> info(new RequestInfo(request, params));
+
+  nsresult rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotaManagerService::ClearStoragesForPrincipal(nsIPrincipal* aPrincipal,
+                                               const nsACString& aPersistenceType,
+                                               bool aClearAll,
+                                               nsIQuotaRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aPrincipal);
+  MOZ_ASSERT(nsContentUtils::IsCallerChrome());
+
+  nsCString suffix;
+  BasePrincipal::Cast(aPrincipal)->OriginAttributesRef().CreateSuffix(suffix);
+
+  if (NS_WARN_IF(aClearAll && !suffix.IsEmpty())) {
+    // The originAttributes should be default originAttributes when the
+    // aClearAll flag is set.
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<Request> request = new Request(aPrincipal);
+
+  ClearOriginParams params;
+
+  PrincipalInfo& principalInfo = params.principalInfo();
+
+  nsresult rv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (principalInfo.type() != PrincipalInfo::TContentPrincipalInfo &&
+      principalInfo.type() != PrincipalInfo::TSystemPrincipalInfo) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  Nullable<PersistenceType> persistenceType;
+  rv = NullablePersistenceTypeFromText(aPersistenceType, &persistenceType);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (persistenceType.IsNull()) {
+    params.persistenceTypeIsExplicit() = false;
+  } else {
+    params.persistenceType() = persistenceType.Value();
+    params.persistenceTypeIsExplicit() = true;
+  }
+
+  params.clearAll() = aClearAll;
+
+  nsAutoPtr<PendingRequestInfo> info(new RequestInfo(request, params));
+
+  rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotaManagerService::Reset(nsIQuotaRequest** _retval)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(nsContentUtils::IsCallerChrome());
+
+  if (NS_WARN_IF(!gTestingMode)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  RefPtr<Request> request = new Request();
+
+  ResetAllParams params;
+
+  nsAutoPtr<PendingRequestInfo> info(new RequestInfo(request, params));
+
+  nsresult rv = InitiateRequest(info);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  request.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotaManagerService::Observe(nsISupports* aSubject,
+                             const char* aTopic,
+                             const char16_t* aData)
+{
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!strcmp(aTopic, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID)) {
+    RemoveIdleObserver();
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, "clear-origin-attributes-data")) {
+    RefPtr<Request> request = new Request();
+
+    ClearOriginsParams requestParams;
+    requestParams.pattern() = nsDependentString(aData);
+
+    nsAutoPtr<PendingRequestInfo> info(new RequestInfo(request, requestParams));
+
+    nsresult rv = InitiateRequest(info);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, OBSERVER_TOPIC_IDLE_DAILY)) {
+    PerformIdleMaintenance();
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, OBSERVER_TOPIC_IDLE)) {
+    nsAutoPtr<PendingRequestInfo> info(
+      new IdleMaintenanceInfo(/* aStart */ true));
+
+    nsresult rv = InitiateRequest(info);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, OBSERVER_TOPIC_ACTIVE)) {
+    RemoveIdleObserver();
+
+    nsAutoPtr<PendingRequestInfo> info(
+      new IdleMaintenanceInfo(/* aStart */ false));
+
+    nsresult rv = InitiateRequest(info);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  MOZ_ASSERT_UNREACHABLE("Should never get here!");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+AbortOperationsRunnable::Run()
+{
+  AssertIsOnBackgroundThread();
+
+  if (QuotaManager::IsShuttingDown()) {
+    return NS_OK;
+  }
+
+  QuotaManager* quotaManager = QuotaManager::Get();
+  if (!quotaManager) {
+    return NS_OK;
+  }
+
+  quotaManager->AbortOperationsForProcess(mContentParentId);
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(QuotaManagerService::BackgroundCreateCallback,
+                  nsIIPCBackgroundChildCreateCallback)
+
+void
+QuotaManagerService::
+BackgroundCreateCallback::ActorCreated(PBackgroundChild* aActor)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+  MOZ_ASSERT(mService);
+
+  RefPtr<QuotaManagerService> service;
+  mService.swap(service);
+
+  service->BackgroundActorCreated(aActor);
+}
+
+void
+QuotaManagerService::
+BackgroundCreateCallback::ActorFailed()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mService);
+
+  RefPtr<QuotaManagerService> service;
+  mService.swap(service);
+
+  service->BackgroundActorFailed();
+}
+
+nsresult
+QuotaManagerService::
+UsageRequestInfo::InitiateRequest(QuotaChild* aActor)
+{
+  MOZ_ASSERT(aActor);
+
+  auto request = static_cast<UsageRequest*>(mRequest.get());
+
+  auto actor = new QuotaUsageRequestChild(request);
+
+  if (!aActor->SendPQuotaUsageRequestConstructor(actor, mParams)) {
+    request->SetError(NS_ERROR_FAILURE);
+    return NS_ERROR_FAILURE;
+  }
+
+  request->SetBackgroundActor(actor);
+
+  return NS_OK;
+}
+
+nsresult
+QuotaManagerService::
+RequestInfo::InitiateRequest(QuotaChild* aActor)
+{
+  MOZ_ASSERT(aActor);
+
+  auto request = static_cast<Request*>(mRequest.get());
+
+  auto actor = new QuotaRequestChild(request);
+
+  if (!aActor->SendPQuotaRequestConstructor(actor, mParams)) {
+    request->SetError(NS_ERROR_FAILURE);
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+QuotaManagerService::
+IdleMaintenanceInfo::InitiateRequest(QuotaChild* aActor)
+{
+  MOZ_ASSERT(aActor);
+
+  bool result;
+
+  if (mStart) {
+    result = aActor->SendStartIdleMaintenance();
+  } else {
+    result = aActor->SendStopIdleMaintenance();
+  }
+
+  if (!result) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+} // namespace quota
+} // namespace dom
+} // namespace mozilla