dom/localstorage/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 #include "ErrorList.h"
  10 #include "LSDatabase.h"
  11 #include "LSObserver.h"
  12 #include "LSSnapshot.h"
  13 #include "LocalStorageCommon.h"
  14 #include "mozilla/Assertions.h"
  15 #include "mozilla/Result.h"
  16 #include "mozilla/dom/LSValue.h"
  17 #include "mozilla/dom/Storage.h"
  18 #include "mozilla/dom/quota/QuotaCommon.h"
  19 #include "mozilla/ipc/BackgroundUtils.h"
  20 #include "nsCOMPtr.h"
  21
  22 namespace mozilla::dom {
  23
  24 /*******************************************************************************
  25  * LSDatabaseChild
  26  ******************************************************************************/
  27
  28 LSDatabaseChild::LSDatabaseChild(LSDatabase* aDatabase) : mDatabase(aDatabase) {
  29   AssertIsOnOwningThread();
  30   MOZ_ASSERT(aDatabase);
  31
  32   MOZ_COUNT_CTOR(LSDatabaseChild);
  33 }
  34
  35 LSDatabaseChild::~LSDatabaseChild() {
  36   AssertIsOnOwningThread();
  37
  38   MOZ_COUNT_DTOR(LSDatabaseChild);
  39 }
  40
  41 void LSDatabaseChild::SendDeleteMeInternal() {
  42   AssertIsOnOwningThread();
  43
  44   if (mDatabase) {
  45     mDatabase->ClearActor();
  46     mDatabase = nullptr;
  47
  48     MOZ_ALWAYS_TRUE(PBackgroundLSDatabaseChild::SendDeleteMe());
  49   }
  50 }
  51
  52 void LSDatabaseChild::ActorDestroy(ActorDestroyReason aWhy) {
  53   AssertIsOnOwningThread();
  54
  55   if (mDatabase) {
  56     mDatabase->ClearActor();
  57 #ifdef DEBUG
  58     mDatabase = nullptr;
  59 #endif
  60   }
  61 }
  62
  63 mozilla::ipc::IPCResult LSDatabaseChild::RecvRequestAllowToClose() {
  64   AssertIsOnOwningThread();
  65
  66   if (mDatabase) {
  67     mDatabase->RequestAllowToClose();
  68
  69     // TODO: A new datastore will be prepared at first LocalStorage API
  70     //       synchronous call. It would be better to start preparing a new
  71     //       datastore right here, but asynchronously.
  72     //       However, we probably shouldn't do that if we are shutting down.
  73   }
  74
  75   return IPC_OK();
  76 }
  77
  78 PBackgroundLSSnapshotChild* LSDatabaseChild::AllocPBackgroundLSSnapshotChild(
  79     const nsAString& aDocumentURI, const nsAString& aKey,
  80     const bool& aIncreasePeakUsage, const int64_t& aMinSize,
  81     LSSnapshotInitInfo* aInitInfo) {
  82   MOZ_CRASH("PBackgroundLSSnapshotChild actor should be manually constructed!");
  83 }
  84
  85 bool LSDatabaseChild::DeallocPBackgroundLSSnapshotChild(
  86     PBackgroundLSSnapshotChild* aActor) {
  87   MOZ_ASSERT(aActor);
  88
  89   delete aActor;
  90   return true;
  91 }
  92
  93 /*******************************************************************************
  94  * LSObserverChild
  95  ******************************************************************************/
  96
  97 LSObserverChild::LSObserverChild(LSObserver* aObserver) : mObserver(aObserver) {
  98   AssertIsOnOwningThread();
  99   MOZ_ASSERT(aObserver);
 100
 101   MOZ_COUNT_CTOR(LSObserverChild);
 102 }
 103
 104 LSObserverChild::~LSObserverChild() {
 105   AssertIsOnOwningThread();
 106
 107   MOZ_COUNT_DTOR(LSObserverChild);
 108 }
 109
 110 void LSObserverChild::SendDeleteMeInternal() {
 111   AssertIsOnOwningThread();
 112
 113   if (mObserver) {
 114     mObserver->ClearActor();
 115     mObserver = nullptr;
 116
 117     MOZ_ALWAYS_TRUE(PBackgroundLSObserverChild::SendDeleteMe());
 118   }
 119 }
 120
 121 void LSObserverChild::ActorDestroy(ActorDestroyReason aWhy) {
 122   AssertIsOnOwningThread();
 123
 124   if (mObserver) {
 125     mObserver->ClearActor();
 126 #ifdef DEBUG
 127     mObserver = nullptr;
 128 #endif
 129   }
 130 }
 131
 132 mozilla::ipc::IPCResult LSObserverChild::RecvObserve(
 133     const PrincipalInfo& aPrincipalInfo, const uint32_t& aPrivateBrowsingId,
 134     const nsAString& aDocumentURI, const nsAString& aKey,
 135     const LSValue& aOldValue, const LSValue& aNewValue) {
 136   AssertIsOnOwningThread();
 137
 138   if (!mObserver) {
 139     return IPC_OK();
 140   }
 141
 142   QM_TRY_INSPECT(const auto& principal,
 143                  PrincipalInfoToPrincipal(aPrincipalInfo),
 144                  IPC_FAIL(this, "PrincipalInfoToPrincipal failed!"));
 145
 146   Storage::NotifyChange(/* aStorage */ nullptr, principal, aKey,
 147                         aOldValue.AsString(), aNewValue.AsString(),
 148                         /* aStorageType */ kLocalStorageType, aDocumentURI,
 149                         /* aIsPrivate */ !!aPrivateBrowsingId,
 150                         /* aImmediateDispatch */ true);
 151
 152   return IPC_OK();
 153 }
 154
 155 /*******************************************************************************
 156  * LocalStorageRequestChild
 157  ******************************************************************************/
 158
 159 LSRequestChild::LSRequestChild() : mFinishing(false) {
 160   AssertIsOnOwningThread();
 161
 162   MOZ_COUNT_CTOR(LSRequestChild);
 163 }
 164
 165 LSRequestChild::~LSRequestChild() {
 166   AssertIsOnOwningThread();
 167   MOZ_ASSERT(!mCallback);
 168
 169   MOZ_COUNT_DTOR(LSRequestChild);
 170 }
 171
 172 void LSRequestChild::SetCallback(LSRequestChildCallback* aCallback) {
 173   AssertIsOnOwningThread();
 174   MOZ_ASSERT(aCallback);
 175   MOZ_ASSERT(!mCallback);
 176   MOZ_ASSERT(Manager());
 177
 178   mCallback = aCallback;
 179 }
 180
 181 bool LSRequestChild::Finishing() const {
 182   AssertIsOnOwningThread();
 183
 184   return mFinishing;
 185 }
 186
 187 void LSRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
 188   AssertIsOnOwningThread();
 189
 190   if (mCallback) {
 191     MOZ_ASSERT(aWhy != Deletion);
 192
 193     mCallback->OnResponse(NS_ERROR_FAILURE);
 194
 195     mCallback = nullptr;
 196   }
 197 }
 198
 199 mozilla::ipc::IPCResult LSRequestChild::Recv__delete__(
 200     const LSRequestResponse& aResponse) {
 201   AssertIsOnOwningThread();
 202   MOZ_ASSERT(mCallback);
 203
 204   mCallback->OnResponse(aResponse);
 205
 206   mCallback = nullptr;
 207
 208   return IPC_OK();
 209 }
 210
 211 mozilla::ipc::IPCResult LSRequestChild::RecvReady() {
 212   AssertIsOnOwningThread();
 213
 214   mFinishing = true;
 215
 216   // We only expect this to return false if the channel has been closed, but
 217   // PBackground's channel never gets shutdown.
 218   MOZ_ALWAYS_TRUE(SendFinish());
 219
 220   return IPC_OK();
 221 }
 222
 223 /*******************************************************************************
 224  * LSSimpleRequestChild
 225  ******************************************************************************/
 226
 227 LSSimpleRequestChild::LSSimpleRequestChild() {
 228   AssertIsOnOwningThread();
 229
 230   MOZ_COUNT_CTOR(LSSimpleRequestChild);
 231 }
 232
 233 LSSimpleRequestChild::~LSSimpleRequestChild() {
 234   AssertIsOnOwningThread();
 235   MOZ_ASSERT(!mCallback);
 236
 237   MOZ_COUNT_DTOR(LSSimpleRequestChild);
 238 }
 239
 240 void LSSimpleRequestChild::SetCallback(
 241     LSSimpleRequestChildCallback* aCallback) {
 242   AssertIsOnOwningThread();
 243   MOZ_ASSERT(aCallback);
 244   MOZ_ASSERT(!mCallback);
 245   MOZ_ASSERT(Manager());
 246
 247   mCallback = aCallback;
 248 }
 249
 250 void LSSimpleRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
 251   AssertIsOnOwningThread();
 252
 253   if (mCallback) {
 254     MOZ_ASSERT(aWhy != Deletion);
 255
 256     mCallback->OnResponse(NS_ERROR_FAILURE);
 257
 258     mCallback = nullptr;
 259   }
 260 }
 261
 262 mozilla::ipc::IPCResult LSSimpleRequestChild::Recv__delete__(
 263     const LSSimpleRequestResponse& aResponse) {
 264   AssertIsOnOwningThread();
 265   MOZ_ASSERT(mCallback);
 266
 267   mCallback->OnResponse(aResponse);
 268
 269   mCallback = nullptr;
 270
 271   return IPC_OK();
 272 }
 273
 274 /*******************************************************************************
 275  * LSSnapshotChild
 276  ******************************************************************************/
 277
 278 LSSnapshotChild::LSSnapshotChild(LSSnapshot* aSnapshot) : mSnapshot(aSnapshot) {
 279   AssertIsOnOwningThread();
 280   MOZ_ASSERT(aSnapshot);
 281
 282   MOZ_COUNT_CTOR(LSSnapshotChild);
 283 }
 284
 285 LSSnapshotChild::~LSSnapshotChild() {
 286   AssertIsOnOwningThread();
 287
 288   MOZ_COUNT_DTOR(LSSnapshotChild);
 289 }
 290
 291 void LSSnapshotChild::SendDeleteMeInternal() {
 292   AssertIsOnOwningThread();
 293
 294   if (mSnapshot) {
 295     mSnapshot->ClearActor();
 296     mSnapshot = nullptr;
 297
 298     MOZ_ALWAYS_TRUE(PBackgroundLSSnapshotChild::SendDeleteMe());
 299   }
 300 }
 301
 302 void LSSnapshotChild::ActorDestroy(ActorDestroyReason aWhy) {
 303   AssertIsOnOwningThread();
 304
 305   if (mSnapshot) {
 306     mSnapshot->ClearActor();
 307 #ifdef DEBUG
 308     mSnapshot = nullptr;
 309 #endif
 310   }
 311 }
 312
 313 mozilla::ipc::IPCResult LSSnapshotChild::RecvMarkDirty() {
 314   AssertIsOnOwningThread();
 315
 316   if (!mSnapshot) {
 317     return IPC_OK();
 318   }
 319
 320   mSnapshot->MarkDirty();
 321
 322   return IPC_OK();
 323 }
 324
 325 }  // namespace mozilla::dom