dom/storage/SessionStorageManager.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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "SessionStorageManager.h"
   8
   9 #include "StorageIPC.h"
  10 #include "SessionStorage.h"
  11 #include "SessionStorageCache.h"
  12 #include "SessionStorageObserver.h"
  13 #include "StorageUtils.h"
  14 #include "mozilla/ClearOnShutdown.h"
  15 #include "mozilla/OriginAttributes.h"
  16 #include "mozilla/PrincipalHashKey.h"
  17 #include "mozilla/ScopeExit.h"
  18 #include "mozilla/StoragePrincipalHelper.h"
  19 #include "mozilla/dom/CanonicalBrowsingContext.h"
  20 #include "mozilla/dom/ContentChild.h"
  21 #include "mozilla/dom/LocalStorageCommon.h"
  22 #include "mozilla/dom/PBackgroundSessionStorageCache.h"
  23 #include "mozilla/dom/PBackgroundSessionStorageManager.h"
  24 #include "mozilla/dom/PermissionMessageUtils.h"
  25 #include "mozilla/dom/WindowGlobalParent.h"
  26 #include "mozilla/ipc/BackgroundChild.h"
  27 #include "mozilla/ipc/BackgroundParent.h"
  28 #include "mozilla/ipc/PBackgroundChild.h"
  29 #include "nsTHashMap.h"
  30 #include "nsThreadUtils.h"
  31
  32 namespace mozilla {
  33 namespace dom {
  34
  35 using namespace StorageUtils;
  36
  37 // Parent process, background thread hashmap that stores top context id and
  38 // manager pair.
  39 static StaticAutoPtr<
  40     nsRefPtrHashtable<nsUint64HashKey, BackgroundSessionStorageManager>>
  41     sManagers;
  42
  43 bool RecvShutdownBackgroundSessionStorageManagers() {
  44   ::mozilla::ipc::AssertIsOnBackgroundThread();
  45
  46   sManagers = nullptr;
  47   return true;
  48 }
  49
  50 void RecvPropagateBackgroundSessionStorageManager(
  51     uint64_t aCurrentTopContextId, uint64_t aTargetTopContextId) {
  52   ::mozilla::ipc::AssertIsOnBackgroundThread();
  53
  54   if (sManagers) {
  55     if (RefPtr<BackgroundSessionStorageManager> mgr =
  56             sManagers->Get(aCurrentTopContextId)) {
  57       mgr->MaybeDispatchSessionStoreUpdate();
  58       mgr->SetCurrentBrowsingContextId(aTargetTopContextId);
  59       // Because of bfcache, we may re-register aTargetTopContextId in
  60       // CanonicalBrowsingContext::ReplacedBy.
  61       // XXXBFCache do we want to tweak this behavior and ensure this is
  62       // called only once?
  63       sManagers->InsertOrUpdate(aTargetTopContextId, std::move(mgr));
  64     }
  65   }
  66 }
  67
  68 bool RecvRemoveBackgroundSessionStorageManager(uint64_t aTopContextId) {
  69   ::mozilla::ipc::AssertIsOnBackgroundThread();
  70
  71   if (sManagers) {
  72     RefPtr<BackgroundSessionStorageManager> mgr;
  73     sManagers->Remove(aTopContextId, getter_AddRefs(mgr));
  74
  75     if (mgr) {
  76       mgr->CancelSessionStoreUpdate();
  77     }
  78   }
  79
  80   return true;
  81 }
  82
  83 bool RecvLoadSessionStorageData(
  84     uint64_t aTopContextId,
  85     nsTArray<mozilla::dom::SSCacheCopy>&& aCacheCopyList) {
  86   if (aCacheCopyList.IsEmpty()) {
  87     return true;
  88   }
  89
  90   RefPtr<BackgroundSessionStorageManager> manager =
  91       BackgroundSessionStorageManager::GetOrCreate(aTopContextId);
  92
  93   if (!manager) {
  94     return true;
  95   }
  96
  97   for (const auto& cacheInit : aCacheCopyList) {
  98     OriginAttributes attrs;
  99     StoragePrincipalHelper::GetOriginAttributes(cacheInit.principalInfo(),
 100                                                 attrs);
 101
 102     nsAutoCString originAttrs;
 103     attrs.CreateSuffix(originAttrs);
 104
 105     manager->UpdateData(originAttrs, cacheInit.originKey(), cacheInit.data());
 106   }
 107
 108   return true;
 109 }
 110
 111 bool RecvGetSessionStorageData(
 112     uint64_t aTopContextId, uint32_t aSizeLimit, bool aCancelSessionStoreTimer,
 113     ::mozilla::ipc::PBackgroundParent::GetSessionStorageManagerDataResolver&&
 114         aResolver) {
 115   nsTArray<mozilla::dom::SSCacheCopy> data;
 116   auto resolve = MakeScopeExit([&]() { aResolver(std::move(data)); });
 117
 118   if (!sManagers) {
 119     return true;
 120   }
 121
 122   RefPtr<BackgroundSessionStorageManager> manager =
 123       sManagers->Get(aTopContextId);
 124   if (!manager) {
 125     return true;
 126   }
 127
 128   if (aCancelSessionStoreTimer) {
 129     manager->CancelSessionStoreUpdate();
 130   }
 131
 132   manager->GetData(aSizeLimit, data);
 133
 134   return true;
 135 }
 136
 137 void SessionStorageManagerBase::ClearStoragesInternal(
 138     const OriginAttributesPattern& aPattern, const nsACString& aOriginScope) {
 139   for (const auto& oaEntry : mOATable) {
 140     OriginAttributes oa;
 141     DebugOnly<bool> ok = oa.PopulateFromSuffix(oaEntry.GetKey());
 142     MOZ_ASSERT(ok);
 143     if (!aPattern.Matches(oa)) {
 144       // This table doesn't match the given origin attributes pattern
 145       continue;
 146     }
 147
 148     OriginKeyHashTable* table = oaEntry.GetWeak();
 149     for (const auto& originKeyEntry : *table) {
 150       if (aOriginScope.IsEmpty() ||
 151           StringBeginsWith(originKeyEntry.GetKey(), aOriginScope)) {
 152         const auto cache = originKeyEntry.GetData()->mCache;
 153         cache->Clear(false);
 154         cache->ResetWriteInfos();
 155       }
 156     }
 157   }
 158 }
 159
 160 SessionStorageManagerBase::OriginRecord*
 161 SessionStorageManagerBase::GetOriginRecord(
 162     const nsACString& aOriginAttrs, const nsACString& aOriginKey,
 163     const bool aMakeIfNeeded, SessionStorageCache* const aCloneFrom) {
 164   // XXX It seems aMakeIfNeeded is always known at compile-time, so this could
 165   // be split into two functions.
 166
 167   if (aMakeIfNeeded) {
 168     return mOATable.GetOrInsertNew(aOriginAttrs)
 169         ->LookupOrInsertWith(
 170             aOriginKey,
 171             [&] {
 172               auto newOriginRecord = MakeUnique<OriginRecord>();
 173               if (aCloneFrom) {
 174                 newOriginRecord->mCache = aCloneFrom->Clone();
 175               } else {
 176                 newOriginRecord->mCache = new SessionStorageCache();
 177               }
 178               return newOriginRecord;
 179             })
 180         .get();
 181   }
 182
 183   auto* const table = mOATable.Get(aOriginAttrs);
 184   if (!table) return nullptr;
 185
 186   return table->Get(aOriginKey);
 187 }
 188
 189 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SessionStorageManager)
 190   NS_INTERFACE_MAP_ENTRY(nsISupports)
 191   NS_INTERFACE_MAP_ENTRY(nsIDOMStorageManager)
 192   NS_INTERFACE_MAP_ENTRY(nsIDOMSessionStorageManager)
 193 NS_INTERFACE_MAP_END
 194
 195 NS_IMPL_CYCLE_COLLECTION(SessionStorageManager, mBrowsingContext)
 196 NS_IMPL_CYCLE_COLLECTING_ADDREF(SessionStorageManager)
 197 NS_IMPL_CYCLE_COLLECTING_RELEASE(SessionStorageManager)
 198
 199 SessionStorageManager::SessionStorageManager(
 200     RefPtr<BrowsingContext> aBrowsingContext)
 201     : mBrowsingContext(std::move(aBrowsingContext)), mActor(nullptr) {
 202   AssertIsOnMainThread();
 203
 204   StorageObserver* observer = StorageObserver::Self();
 205   NS_ASSERTION(
 206       observer,
 207       "No StorageObserver, cannot observe private data delete notifications!");
 208
 209   if (observer) {
 210     observer->AddSink(this);
 211   }
 212
 213   if (!XRE_IsParentProcess() && NextGenLocalStorageEnabled()) {
 214     // When LSNG is enabled the thread IPC bridge doesn't exist, so we have to
 215     // create own protocol to distribute chrome observer notifications to
 216     // content processes.
 217     mObserver = SessionStorageObserver::Get();
 218
 219     if (!mObserver) {
 220       ContentChild* contentActor = ContentChild::GetSingleton();
 221       MOZ_ASSERT(contentActor);
 222
 223       RefPtr<SessionStorageObserver> observer = new SessionStorageObserver();
 224
 225       SessionStorageObserverChild* actor =
 226           new SessionStorageObserverChild(observer);
 227
 228       MOZ_ALWAYS_TRUE(
 229           contentActor->SendPSessionStorageObserverConstructor(actor));
 230
 231       observer->SetActor(actor);
 232
 233       mObserver = std::move(observer);
 234     }
 235   }
 236 }
 237
 238 SessionStorageManager::~SessionStorageManager() {
 239   StorageObserver* observer = StorageObserver::Self();
 240   if (observer) {
 241     observer->RemoveSink(this);
 242   }
 243
 244   if (mActor) {
 245     mActor->SendDeleteMeInternal();
 246     MOZ_ASSERT(!mActor, "SendDeleteMeInternal should have cleared!");
 247   }
 248 }
 249
 250 bool SessionStorageManager::CanLoadData() {
 251   AssertIsOnMainThread();
 252
 253   return mBrowsingContext && !mBrowsingContext->IsDiscarded();
 254 }
 255
 256 void SessionStorageManager::SetActor(SessionStorageManagerChild* aActor) {
 257   AssertIsOnMainThread();
 258   MOZ_ASSERT(aActor);
 259   MOZ_ASSERT(!mActor);
 260
 261   mActor = aActor;
 262 }
 263
 264 bool SessionStorageManager::ActorExists() const {
 265   AssertIsOnMainThread();
 266
 267   return mActor;
 268 }
 269
 270 void SessionStorageManager::ClearActor() {
 271   AssertIsOnMainThread();
 272   MOZ_ASSERT(mActor);
 273
 274   mActor = nullptr;
 275 }
 276
 277 nsresult SessionStorageManager::EnsureManager() {
 278   AssertIsOnMainThread();
 279   MOZ_ASSERT(CanLoadData());
 280
 281   if (ActorExists()) {
 282     return NS_OK;
 283   }
 284
 285   ::mozilla::ipc::PBackgroundChild* backgroundActor =
 286       ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
 287   if (NS_WARN_IF(!backgroundActor)) {
 288     return NS_ERROR_FAILURE;
 289   }
 290
 291   RefPtr<SessionStorageManagerChild> actor =
 292       new SessionStorageManagerChild(this);
 293
 294   if (!backgroundActor->SendPBackgroundSessionStorageManagerConstructor(
 295           actor, mBrowsingContext->Top()->Id())) {
 296     return NS_ERROR_FAILURE;
 297   }
 298
 299   SetActor(actor);
 300
 301   return NS_OK;
 302 }
 303
 304 SessionStorageCacheChild* SessionStorageManager::EnsureCache(
 305     nsIPrincipal& aPrincipal, const nsCString& aOriginKey,
 306     SessionStorageCache& aCache) {
 307   AssertIsOnMainThread();
 308   MOZ_ASSERT(CanLoadData());
 309   MOZ_ASSERT(ActorExists());
 310
 311   if (aCache.Actor()) {
 312     return aCache.Actor();
 313   }
 314
 315   mozilla::ipc::PrincipalInfo info;
 316   nsresult rv = PrincipalToPrincipalInfo(&aPrincipal, &info);
 317
 318   if (NS_FAILED(rv)) {
 319     return nullptr;
 320   }
 321
 322   RefPtr<SessionStorageCacheChild> actor =
 323       new SessionStorageCacheChild(&aCache);
 324   if (!mActor->SendPBackgroundSessionStorageCacheConstructor(actor, info,
 325                                                              aOriginKey)) {
 326     return nullptr;
 327   }
 328
 329   aCache.SetActor(actor);
 330
 331   return actor;
 332 }
 333
 334 nsresult SessionStorageManager::LoadData(nsIPrincipal& aPrincipal,
 335                                          SessionStorageCache& aCache) {
 336   AssertIsOnMainThread();
 337   MOZ_ASSERT(mActor);
 338
 339   nsAutoCString originKey;
 340   nsresult rv = aPrincipal.GetStorageOriginKey(originKey);
 341   if (NS_WARN_IF(NS_FAILED(rv))) {
 342     return rv;
 343   }
 344
 345   nsAutoCString originAttributes;
 346   aPrincipal.OriginAttributesRef().CreateSuffix(originAttributes);
 347
 348   auto* const originRecord =
 349       GetOriginRecord(originAttributes, originKey, true, nullptr);
 350   MOZ_ASSERT(originRecord);
 351
 352   if (originRecord->mLoaded) {
 353     return NS_OK;
 354   }
 355
 356   RefPtr<SessionStorageCacheChild> cacheActor =
 357       EnsureCache(aPrincipal, originKey, aCache);
 358
 359   if (!cacheActor) {
 360     return NS_ERROR_FAILURE;
 361   }
 362
 363   nsTArray<SSSetItemInfo> data;
 364   if (!cacheActor->SendLoad(&data)) {
 365     return NS_ERROR_FAILURE;
 366   }
 367
 368   originRecord->mCache->DeserializeData(data);
 369
 370   originRecord->mLoaded.Flip();
 371   aCache.SetLoadedOrCloned();
 372
 373   return NS_OK;
 374 }
 375
 376 void SessionStorageManager::CheckpointData(nsIPrincipal& aPrincipal,
 377                                            SessionStorageCache& aCache) {
 378   AssertIsOnMainThread();
 379   MOZ_ASSERT(mActor);
 380
 381   nsAutoCString originKey;
 382   nsresult rv = aPrincipal.GetStorageOriginKey(originKey);
 383   if (NS_WARN_IF(NS_FAILED(rv))) {
 384     return;
 385   }
 386
 387   return CheckpointDataInternal(aPrincipal, originKey, aCache);
 388 }
 389
 390 void SessionStorageManager::CheckpointDataInternal(
 391     nsIPrincipal& aPrincipal, const nsCString& aOriginKey,
 392     SessionStorageCache& aCache) {
 393   AssertIsOnMainThread();
 394   MOZ_ASSERT(mActor);
 395
 396   nsTArray<SSWriteInfo> writeInfos = aCache.SerializeWriteInfos();
 397
 398   if (writeInfos.IsEmpty()) {
 399     return;
 400   }
 401
 402   RefPtr<SessionStorageCacheChild> cacheActor =
 403       EnsureCache(aPrincipal, aOriginKey, aCache);
 404
 405   if (!cacheActor) {
 406     return;
 407   }
 408
 409   Unused << cacheActor->SendCheckpoint(writeInfos);
 410
 411   aCache.ResetWriteInfos();
 412 }
 413
 414 NS_IMETHODIMP
 415 SessionStorageManager::PrecacheStorage(nsIPrincipal* aPrincipal,
 416                                        nsIPrincipal* aStoragePrincipal,
 417                                        Storage** aRetval) {
 418   // Nothing to preload.
 419   return NS_OK;
 420 }
 421
 422 NS_IMETHODIMP
 423 SessionStorageManager::GetSessionStorageCache(
 424     nsIPrincipal* aPrincipal, nsIPrincipal* aStoragePrincipal,
 425     RefPtr<SessionStorageCache>* aRetVal) {
 426   return GetSessionStorageCacheHelper(aStoragePrincipal, true, nullptr,
 427                                       aRetVal);
 428 }
 429
 430 nsresult SessionStorageManager::GetSessionStorageCacheHelper(
 431     nsIPrincipal* aPrincipal, bool aMakeIfNeeded,
 432     SessionStorageCache* aCloneFrom, RefPtr<SessionStorageCache>* aRetVal) {
 433   nsAutoCString originKey;
 434   nsAutoCString originAttributes;
 435   nsresult rv = aPrincipal->GetStorageOriginKey(originKey);
 436   aPrincipal->OriginAttributesRef().CreateSuffix(originAttributes);
 437   if (NS_FAILED(rv)) {
 438     return NS_ERROR_NOT_AVAILABLE;
 439   }
 440
 441   return GetSessionStorageCacheHelper(originAttributes, originKey,
 442                                       aMakeIfNeeded, aCloneFrom, aRetVal);
 443 }
 444
 445 nsresult SessionStorageManager::GetSessionStorageCacheHelper(
 446     const nsACString& aOriginAttrs, const nsACString& aOriginKey,
 447     bool aMakeIfNeeded, SessionStorageCache* aCloneFrom,
 448     RefPtr<SessionStorageCache>* aRetVal) {
 449   if (OriginRecord* const originRecord = GetOriginRecord(
 450           aOriginAttrs, aOriginKey, aMakeIfNeeded, aCloneFrom)) {
 451     *aRetVal = originRecord->mCache;
 452   } else {
 453     *aRetVal = nullptr;
 454   }
 455   return NS_OK;
 456 }
 457
 458 NS_IMETHODIMP
 459 SessionStorageManager::CreateStorage(mozIDOMWindow* aWindow,
 460                                      nsIPrincipal* aPrincipal,
 461                                      nsIPrincipal* aStoragePrincipal,
 462                                      const nsAString& aDocumentURI,
 463                                      bool aPrivate, Storage** aRetval) {
 464   RefPtr<SessionStorageCache> cache;
 465   nsresult rv = GetSessionStorageCache(aPrincipal, aStoragePrincipal, &cache);
 466   if (NS_FAILED(rv)) {
 467     return rv;
 468   }
 469
 470   nsCOMPtr<nsPIDOMWindowInner> inner = nsPIDOMWindowInner::From(aWindow);
 471
 472   RefPtr<SessionStorage> storage =
 473       new SessionStorage(inner, aPrincipal, aStoragePrincipal, cache, this,
 474                          aDocumentURI, aPrivate);
 475
 476   storage.forget(aRetval);
 477   return NS_OK;
 478 }
 479
 480 NS_IMETHODIMP
 481 SessionStorageManager::GetStorage(mozIDOMWindow* aWindow,
 482                                   nsIPrincipal* aPrincipal,
 483                                   nsIPrincipal* aStoragePrincipal,
 484                                   bool aPrivate, Storage** aRetval) {
 485   *aRetval = nullptr;
 486
 487   RefPtr<SessionStorageCache> cache;
 488   nsresult rv =
 489       GetSessionStorageCacheHelper(aStoragePrincipal, false, nullptr, &cache);
 490   if (NS_FAILED(rv) || !cache) {
 491     return rv;
 492   }
 493
 494   nsCOMPtr<nsPIDOMWindowInner> inner = nsPIDOMWindowInner::From(aWindow);
 495
 496   RefPtr<SessionStorage> storage = new SessionStorage(
 497       inner, aPrincipal, aStoragePrincipal, cache, this, u""_ns, aPrivate);
 498
 499   storage.forget(aRetval);
 500   return NS_OK;
 501 }
 502
 503 NS_IMETHODIMP
 504 SessionStorageManager::CloneStorage(Storage* aStorage) {
 505   if (NS_WARN_IF(!aStorage)) {
 506     return NS_ERROR_UNEXPECTED;
 507   }
 508
 509   if (aStorage->Type() != Storage::eSessionStorage) {
 510     return NS_ERROR_UNEXPECTED;
 511   }
 512
 513   // ToDo: At the moment, we clone the cache on the child process and then
 514   // send the checkpoint.  It would be nicer if we either serailizing all the
 515   // data and sync to the parent process directly or clonig storage on the
 516   // parnet process and sync it to the child process on demand.
 517
 518   RefPtr<SessionStorageCache> cache;
 519   nsresult rv = GetSessionStorageCacheHelper(
 520       aStorage->StoragePrincipal(), true,
 521       static_cast<SessionStorage*>(aStorage)->Cache(), &cache);
 522   if (NS_WARN_IF(NS_FAILED(rv))) {
 523     return rv;
 524   }
 525
 526   // If cache was cloned from other storage, then we shouldn't load the cache
 527   // at the first access.
 528   cache->SetLoadedOrCloned();
 529
 530   if (CanLoadData()) {
 531     rv = EnsureManager();
 532     if (NS_WARN_IF(NS_FAILED(rv))) {
 533       return rv;
 534     }
 535
 536     CheckpointData(*aStorage->StoragePrincipal(), *cache);
 537   }
 538
 539   return rv;
 540 }
 541
 542 NS_IMETHODIMP
 543 SessionStorageManager::CheckStorage(nsIPrincipal* aPrincipal, Storage* aStorage,
 544                                     bool* aRetval) {
 545   if (NS_WARN_IF(!aStorage)) {
 546     return NS_ERROR_UNEXPECTED;
 547   }
 548
 549   if (!aPrincipal) {
 550     return NS_ERROR_NOT_AVAILABLE;
 551   }
 552
 553   *aRetval = false;
 554
 555   RefPtr<SessionStorageCache> cache;
 556   nsresult rv =
 557       GetSessionStorageCacheHelper(aPrincipal, false, nullptr, &cache);
 558   if (NS_FAILED(rv) || !cache) {
 559     return rv;
 560   }
 561
 562   if (aStorage->Type() != Storage::eSessionStorage) {
 563     return NS_OK;
 564   }
 565
 566   RefPtr<SessionStorage> sessionStorage =
 567       static_cast<SessionStorage*>(aStorage);
 568   if (sessionStorage->Cache() != cache) {
 569     return NS_OK;
 570   }
 571
 572   if (!StorageUtils::PrincipalsEqual(aStorage->StoragePrincipal(),
 573                                      aPrincipal)) {
 574     return NS_OK;
 575   }
 576
 577   *aRetval = true;
 578   return NS_OK;
 579 }
 580
 581 void SessionStorageManager::ClearStorages(
 582     const OriginAttributesPattern& aPattern, const nsACString& aOriginScope) {
 583   if (CanLoadData()) {
 584     nsresult rv = EnsureManager();
 585     if (NS_WARN_IF(NS_FAILED(rv))) {
 586       return;
 587     }
 588
 589     mActor->SendClearStorages(aPattern, nsCString(aOriginScope));
 590   }
 591
 592   ClearStoragesInternal(aPattern, aOriginScope);
 593 }
 594
 595 nsresult SessionStorageManager::Observe(
 596     const char* aTopic, const nsAString& aOriginAttributesPattern,
 597     const nsACString& aOriginScope) {
 598   OriginAttributesPattern pattern;
 599   if (!pattern.Init(aOriginAttributesPattern)) {
 600     NS_ERROR("Cannot parse origin attributes pattern");
 601     return NS_ERROR_FAILURE;
 602   }
 603
 604   // Clear everything, caches + database
 605   if (!strcmp(aTopic, "cookie-cleared")) {
 606     ClearStorages(pattern, ""_ns);
 607     return NS_OK;
 608   }
 609
 610   // Clear from caches everything that has been stored
 611   // while in session-only mode
 612   if (!strcmp(aTopic, "session-only-cleared")) {
 613     ClearStorages(pattern, aOriginScope);
 614     return NS_OK;
 615   }
 616
 617   // Clear everything (including so and pb data) from caches and database
 618   // for the given domain and subdomains.
 619   if (!strcmp(aTopic, "browser:purge-sessionStorage")) {
 620     ClearStorages(pattern, aOriginScope);
 621     return NS_OK;
 622   }
 623
 624   // Clear entries which match an OriginAttributesPattern.
 625   if (!strcmp(aTopic, "dom-storage:clear-origin-attributes-data") ||
 626       !strcmp(aTopic, "session-storage:clear-origin-attributes-data")) {
 627     ClearStorages(pattern, aOriginScope);
 628     return NS_OK;
 629   }
 630
 631   if (!strcmp(aTopic, "profile-change")) {
 632     // For case caches are still referenced - clear them completely
 633     ClearStorages(pattern, ""_ns);
 634     mOATable.Clear();
 635     return NS_OK;
 636   }
 637
 638   return NS_OK;
 639 }
 640
 641 SessionStorageManager::OriginRecord::~OriginRecord() = default;
 642
 643 // static
 644 void BackgroundSessionStorageManager::RemoveManager(uint64_t aTopContextId) {
 645   MOZ_ASSERT(XRE_IsParentProcess());
 646   AssertIsOnMainThread();
 647
 648   ::mozilla::ipc::PBackgroundChild* backgroundActor =
 649       ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
 650   if (NS_WARN_IF(!backgroundActor)) {
 651     return;
 652   }
 653
 654   if (NS_WARN_IF(!backgroundActor->SendRemoveBackgroundSessionStorageManager(
 655           aTopContextId))) {
 656     return;
 657   }
 658 }
 659
 660 // static
 661 void BackgroundSessionStorageManager::PropagateManager(
 662     uint64_t aCurrentTopContextId, uint64_t aTargetTopContextId) {
 663   MOZ_ASSERT(XRE_IsParentProcess());
 664   AssertIsOnMainThread();
 665   MOZ_ASSERT(aCurrentTopContextId != aTargetTopContextId);
 666
 667   ::mozilla::ipc::PBackgroundChild* backgroundActor =
 668       ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
 669   if (NS_WARN_IF(!backgroundActor)) {
 670     return;
 671   }
 672
 673   if (NS_WARN_IF(!backgroundActor->SendPropagateBackgroundSessionStorageManager(
 674           aCurrentTopContextId, aTargetTopContextId))) {
 675     return;
 676   }
 677 }
 678
 679 // static
 680 void BackgroundSessionStorageManager::LoadData(
 681     uint64_t aTopContextId,
 682     const nsTArray<mozilla::dom::SSCacheCopy>& aCacheCopyList) {
 683   MOZ_ASSERT(XRE_IsParentProcess());
 684   AssertIsOnMainThread();
 685
 686   ::mozilla::ipc::PBackgroundChild* backgroundActor =
 687       ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
 688   if (NS_WARN_IF(!backgroundActor)) {
 689     return;
 690   }
 691
 692   if (NS_WARN_IF(!backgroundActor->SendLoadSessionStorageManagerData(
 693           aTopContextId, aCacheCopyList))) {
 694     return;
 695   }
 696 }
 697
 698 // static
 699 BackgroundSessionStorageManager* BackgroundSessionStorageManager::GetOrCreate(
 700     uint64_t aTopContextId) {
 701   MOZ_ASSERT(XRE_IsParentProcess());
 702   ::mozilla::ipc::AssertIsOnBackgroundThread();
 703
 704   if (!sManagers) {
 705     sManagers = new nsRefPtrHashtable<nsUint64HashKey,
 706                                       BackgroundSessionStorageManager>();
 707     NS_DispatchToMainThread(NS_NewRunnableFunction(
 708         "dom::BackgroundSessionStorageManager::GetOrCreate", [] {
 709           RunOnShutdown(
 710               [] {
 711                 ::mozilla::ipc::PBackgroundChild* backgroundActor = ::mozilla::
 712                     ipc::BackgroundChild::GetOrCreateForCurrentThread();
 713                 if (NS_WARN_IF(!backgroundActor)) {
 714                   return;
 715                 }
 716
 717                 if (NS_WARN_IF(
 718                         !backgroundActor
 719                              ->SendShutdownBackgroundSessionStorageManagers())) {
 720                   return;
 721                 }
 722               },
 723               ShutdownPhase::XPCOMShutdown);
 724         }));
 725   }
 726
 727   return sManagers
 728       ->LookupOrInsertWith(
 729           aTopContextId,
 730           [aTopContextId] {
 731             return new BackgroundSessionStorageManager(aTopContextId);
 732           })
 733       .get();
 734 }
 735
 736 BackgroundSessionStorageManager::BackgroundSessionStorageManager(
 737     uint64_t aBrowsingContextId)
 738     : mCurrentBrowsingContextId(aBrowsingContextId) {
 739   MOZ_ASSERT(XRE_IsParentProcess());
 740   ::mozilla::ipc::AssertIsOnBackgroundThread();
 741 }
 742
 743 BackgroundSessionStorageManager::~BackgroundSessionStorageManager() = default;
 744
 745 void BackgroundSessionStorageManager::CopyDataToContentProcess(
 746     const nsACString& aOriginAttrs, const nsACString& aOriginKey,
 747     nsTArray<SSSetItemInfo>& aData) {
 748   MOZ_ASSERT(XRE_IsParentProcess());
 749   ::mozilla::ipc::AssertIsOnBackgroundThread();
 750
 751   auto* const originRecord =
 752       GetOriginRecord(aOriginAttrs, aOriginKey, false, nullptr);
 753   if (!originRecord) {
 754     return;
 755   }
 756
 757   aData = originRecord->mCache->SerializeData();
 758 }
 759
 760 /* static */
 761 RefPtr<BackgroundSessionStorageManager::DataPromise>
 762 BackgroundSessionStorageManager::GetData(BrowsingContext* aContext,
 763                                          uint32_t aSizeLimit,
 764                                          bool aClearSessionStoreTimer) {
 765   MOZ_ASSERT(XRE_IsParentProcess());
 766   MOZ_ASSERT(aContext->IsTop());
 767
 768   AssertIsOnMainThread();
 769
 770   ::mozilla::ipc::PBackgroundChild* backgroundActor =
 771       ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
 772   if (NS_WARN_IF(!backgroundActor)) {
 773     return DataPromise::CreateAndReject(
 774         ::mozilla::ipc::ResponseRejectReason::SendError, __func__);
 775   }
 776
 777   return backgroundActor->SendGetSessionStorageManagerData(
 778       aContext->Id(), aSizeLimit, aClearSessionStoreTimer);
 779 }
 780
 781 void BackgroundSessionStorageManager::GetData(
 782     uint32_t aSizeLimit, nsTArray<SSCacheCopy>& aCacheCopyList) {
 783   for (auto& managerActor : mParticipatingActors) {
 784     for (auto* cacheActor :
 785          managerActor->ManagedPBackgroundSessionStorageCacheParent()) {
 786       auto* cache = static_cast<SessionStorageCacheParent*>(cacheActor);
 787       ::mozilla::ipc::PrincipalInfo info = cache->PrincipalInfo();
 788
 789       OriginAttributes attributes;
 790       StoragePrincipalHelper::GetOriginAttributes(cache->PrincipalInfo(),
 791                                                   attributes);
 792
 793       nsAutoCString originAttrs;
 794       attributes.CreateSuffix(originAttrs);
 795
 796       auto* record =
 797           GetOriginRecord(originAttrs, cache->OriginKey(), false, nullptr);
 798
 799       if (!record) {
 800         continue;
 801       }
 802
 803       if (record->mCache->GetOriginQuotaUsage() > aSizeLimit) {
 804         continue;
 805       }
 806
 807       nsTArray<SSSetItemInfo> data = record->mCache->SerializeData();
 808       if (data.IsEmpty()) {
 809         continue;
 810       }
 811
 812       SSCacheCopy& cacheCopy = *aCacheCopyList.AppendElement();
 813       cacheCopy.originKey() = cache->OriginKey();
 814       cacheCopy.principalInfo() = info;
 815       cacheCopy.data().SwapElements(data);
 816     }
 817   }
 818 }
 819
 820 void BackgroundSessionStorageManager::UpdateData(
 821     const nsACString& aOriginAttrs, const nsACString& aOriginKey,
 822     const nsTArray<SSWriteInfo>& aWriteInfos) {
 823   MOZ_ASSERT(XRE_IsParentProcess());
 824   ::mozilla::ipc::AssertIsOnBackgroundThread();
 825
 826   auto* const originRecord =
 827       GetOriginRecord(aOriginAttrs, aOriginKey, true, nullptr);
 828   MOZ_ASSERT(originRecord);
 829
 830   MaybeScheduleSessionStoreUpdate();
 831
 832   originRecord->mCache->DeserializeWriteInfos(aWriteInfos);
 833 }
 834
 835 void BackgroundSessionStorageManager::UpdateData(
 836     const nsACString& aOriginAttrs, const nsACString& aOriginKey,
 837     const nsTArray<SSSetItemInfo>& aData) {
 838   MOZ_ASSERT(XRE_IsParentProcess());
 839   ::mozilla::ipc::AssertIsOnBackgroundThread();
 840
 841   auto* const originRecord =
 842       GetOriginRecord(aOriginAttrs, aOriginKey, true, nullptr);
 843   MOZ_ASSERT(originRecord);
 844
 845   originRecord->mCache->DeserializeData(aData);
 846 }
 847
 848 void BackgroundSessionStorageManager::ClearStorages(
 849     const OriginAttributesPattern& aPattern, const nsCString& aOriginScope) {
 850   MOZ_ASSERT(XRE_IsParentProcess());
 851   ::mozilla::ipc::AssertIsOnBackgroundThread();
 852   ClearStoragesInternal(aPattern, aOriginScope);
 853 }
 854
 855 void BackgroundSessionStorageManager::SetCurrentBrowsingContextId(
 856     uint64_t aBrowsingContextId) {
 857   MOZ_DIAGNOSTIC_ASSERT(aBrowsingContextId != mCurrentBrowsingContextId);
 858   mCurrentBrowsingContextId = aBrowsingContextId;
 859 }
 860
 861 void BackgroundSessionStorageManager::MaybeScheduleSessionStoreUpdate() {
 862   if constexpr (!SessionStoreUtils::NATIVE_LISTENER) {
 863     return;
 864   }
 865
 866   if (mSessionStoreCallbackTimer) {
 867     return;
 868   }
 869
 870   if (StaticPrefs::browser_sessionstore_debug_no_auto_updates()) {
 871     DispatchSessionStoreUpdate();
 872     return;
 873   }
 874
 875   auto result = NS_NewTimerWithFuncCallback(
 876       [](nsITimer*, void* aClosure) {
 877         auto* mgr = static_cast<BackgroundSessionStorageManager*>(aClosure);
 878         mgr->DispatchSessionStoreUpdate();
 879       },
 880       this, StaticPrefs::browser_sessionstore_interval(),
 881       nsITimer::TYPE_ONE_SHOT,
 882       "BackgroundSessionStorageManager::DispatchSessionStoreUpdate");
 883
 884   if (result.isErr()) {
 885     return;
 886   }
 887
 888   mSessionStoreCallbackTimer = result.unwrap();
 889 }
 890
 891 void BackgroundSessionStorageManager::MaybeDispatchSessionStoreUpdate() {
 892   if (mSessionStoreCallbackTimer) {
 893     BackgroundSessionStorageManager::DispatchSessionStoreUpdate();
 894   }
 895 }
 896
 897 void BackgroundSessionStorageManager::DispatchSessionStoreUpdate() {
 898   ::mozilla::ipc::AssertIsOnBackgroundThread();
 899   NS_DispatchToMainThread(NS_NewRunnableFunction(
 900       "CanonicalBrowsingContext::UpdateSessionStore",
 901       [targetBrowsingContextId = mCurrentBrowsingContextId]() {
 902         CanonicalBrowsingContext::UpdateSessionStoreForStorage(
 903             targetBrowsingContextId);
 904       }));
 905
 906   CancelSessionStoreUpdate();
 907 }
 908
 909 void BackgroundSessionStorageManager::CancelSessionStoreUpdate() {
 910   if (mSessionStoreCallbackTimer) {
 911     mSessionStoreCallbackTimer->Cancel();
 912     mSessionStoreCallbackTimer = nullptr;
 913   }
 914 }
 915
 916 void BackgroundSessionStorageManager::AddParticipatingActor(
 917     SessionStorageManagerParent* aActor) {
 918   ::mozilla::ipc::AssertIsOnBackgroundThread();
 919   mParticipatingActors.AppendElement(aActor);
 920 }
 921
 922 void BackgroundSessionStorageManager::RemoveParticipatingActor(
 923     SessionStorageManagerParent* aActor) {
 924   ::mozilla::ipc::AssertIsOnBackgroundThread();
 925   mParticipatingActors.RemoveElement(aActor);
 926 }
 927
 928 }  // namespace dom
 929 }  // namespace mozilla