dom/serviceworkers/ServiceWorkerRegistrar.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 "ServiceWorkerRegistrar.h"
   8 #include "ServiceWorkerManager.h"
   9 #include "mozilla/dom/ServiceWorkerRegistrarTypes.h"
  10 #include "mozilla/dom/DOMException.h"
  11 #include "mozilla/StaticPrefs_dom.h"
  12
  13 #include "nsIEventTarget.h"
  14 #include "nsIInputStream.h"
  15 #include "nsILineInputStream.h"
  16 #include "nsIObserverService.h"
  17 #include "nsIOutputStream.h"
  18 #include "nsISafeOutputStream.h"
  19 #include "nsIServiceWorkerManager.h"
  20 #include "nsIURI.h"
  21 #include "nsIWritablePropertyBag2.h"
  22
  23 #include "MainThreadUtils.h"
  24 #include "mozilla/ClearOnShutdown.h"
  25 #include "mozilla/CycleCollectedJSContext.h"
  26 #include "mozilla/dom/StorageActivityService.h"
  27 #include "mozilla/ErrorNames.h"
  28 #include "mozilla/ipc/BackgroundChild.h"
  29 #include "mozilla/ipc/BackgroundParent.h"
  30 #include "mozilla/ipc/PBackgroundChild.h"
  31 #include "mozilla/ModuleUtils.h"
  32 #include "mozilla/Result.h"
  33 #include "mozilla/ResultExtensions.h"
  34 #include "mozilla/Services.h"
  35 #include "mozilla/StaticPtr.h"
  36 #include "nsAppDirectoryServiceDefs.h"
  37 #include "nsComponentManagerUtils.h"
  38 #include "nsContentUtils.h"
  39 #include "nsDirectoryServiceUtils.h"
  40 #include "nsNetCID.h"
  41 #include "nsNetUtil.h"
  42 #include "nsServiceManagerUtils.h"
  43 #include "nsThreadUtils.h"
  44 #include "nsXULAppAPI.h"
  45 #include "ServiceWorkerUtils.h"
  46
  47 using namespace mozilla::ipc;
  48
  49 extern mozilla::LazyLogModule sWorkerTelemetryLog;
  50
  51 #ifdef LOG
  52 #  undef LOG
  53 #endif
  54 #define LOG(_args) MOZ_LOG(sWorkerTelemetryLog, LogLevel::Debug, _args);
  55
  56 namespace mozilla::dom {
  57
  58 namespace {
  59
  60 static const char* gSupportedRegistrarVersions[] = {
  61     SERVICEWORKERREGISTRAR_VERSION, "8", "7", "6", "5", "4", "3", "2"};
  62
  63 static const uint32_t kInvalidGeneration = static_cast<uint32_t>(-1);
  64
  65 StaticRefPtr<ServiceWorkerRegistrar> gServiceWorkerRegistrar;
  66
  67 nsresult GetOriginAndBaseDomain(const nsACString& aURL, nsACString& aOrigin,
  68                                 nsACString& aBaseDomain) {
  69   nsCOMPtr<nsIURI> url;
  70   nsresult rv = NS_NewURI(getter_AddRefs(url), aURL);
  71   if (NS_WARN_IF(NS_FAILED(rv))) {
  72     return rv;
  73   }
  74
  75   OriginAttributes attrs;
  76   nsCOMPtr<nsIPrincipal> principal =
  77       BasePrincipal::CreateContentPrincipal(url, attrs);
  78   if (!principal) {
  79     return NS_ERROR_NULL_POINTER;
  80   }
  81
  82   rv = principal->GetOriginNoSuffix(aOrigin);
  83   if (NS_WARN_IF(NS_FAILED(rv))) {
  84     return rv;
  85   }
  86
  87   rv = principal->GetBaseDomain(aBaseDomain);
  88   if (NS_WARN_IF(NS_FAILED(rv))) {
  89     return rv;
  90   }
  91
  92   return NS_OK;
  93 }
  94
  95 nsresult ReadLine(nsILineInputStream* aStream, nsACString& aValue) {
  96   bool hasMoreLines;
  97   nsresult rv = aStream->ReadLine(aValue, &hasMoreLines);
  98   if (NS_WARN_IF(NS_FAILED(rv))) {
  99     return rv;
 100   }
 101
 102   if (NS_WARN_IF(!hasMoreLines)) {
 103     return NS_ERROR_FAILURE;
 104   }
 105
 106   return NS_OK;
 107 }
 108
 109 nsresult CreatePrincipalInfo(nsILineInputStream* aStream,
 110                              ServiceWorkerRegistrationData* aEntry,
 111                              bool aSkipSpec = false) {
 112   nsAutoCString suffix;
 113   nsresult rv = ReadLine(aStream, suffix);
 114   if (NS_WARN_IF(NS_FAILED(rv))) {
 115     return rv;
 116   }
 117
 118   OriginAttributes attrs;
 119   if (!attrs.PopulateFromSuffix(suffix)) {
 120     return NS_ERROR_INVALID_ARG;
 121   }
 122
 123   if (aSkipSpec) {
 124     nsAutoCString unused;
 125     nsresult rv = ReadLine(aStream, unused);
 126     if (NS_WARN_IF(NS_FAILED(rv))) {
 127       return rv;
 128     }
 129   }
 130
 131   rv = ReadLine(aStream, aEntry->scope());
 132   if (NS_WARN_IF(NS_FAILED(rv))) {
 133     return rv;
 134   }
 135
 136   nsCString origin;
 137   nsCString baseDomain;
 138   rv = GetOriginAndBaseDomain(aEntry->scope(), origin, baseDomain);
 139   if (NS_WARN_IF(NS_FAILED(rv))) {
 140     return rv;
 141   }
 142
 143   aEntry->principal() = mozilla::ipc::ContentPrincipalInfo(
 144       attrs, origin, aEntry->scope(), Nothing(), baseDomain);
 145
 146   return NS_OK;
 147 }
 148
 149 const IPCNavigationPreloadState gDefaultNavigationPreloadState(false,
 150                                                                "true"_ns);
 151
 152 }  // namespace
 153
 154 NS_IMPL_ISUPPORTS(ServiceWorkerRegistrar, nsIObserver, nsIAsyncShutdownBlocker)
 155
 156 void ServiceWorkerRegistrar::Initialize() {
 157   MOZ_ASSERT(!gServiceWorkerRegistrar);
 158
 159   if (!XRE_IsParentProcess()) {
 160     return;
 161   }
 162
 163   gServiceWorkerRegistrar = new ServiceWorkerRegistrar();
 164   ClearOnShutdown(&gServiceWorkerRegistrar);
 165
 166   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 167   if (obs) {
 168     DebugOnly<nsresult> rv = obs->AddObserver(gServiceWorkerRegistrar,
 169                                               "profile-after-change", false);
 170     MOZ_ASSERT(NS_SUCCEEDED(rv));
 171   }
 172 }
 173
 174 /* static */
 175 already_AddRefed<ServiceWorkerRegistrar> ServiceWorkerRegistrar::Get() {
 176   MOZ_ASSERT(XRE_IsParentProcess());
 177
 178   MOZ_ASSERT(gServiceWorkerRegistrar);
 179   RefPtr<ServiceWorkerRegistrar> service = gServiceWorkerRegistrar.get();
 180   return service.forget();
 181 }
 182
 183 ServiceWorkerRegistrar::ServiceWorkerRegistrar()
 184     : mMonitor("ServiceWorkerRegistrar.mMonitor"),
 185       mDataLoaded(false),
 186       mDataGeneration(kInvalidGeneration),
 187       mFileGeneration(kInvalidGeneration),
 188       mRetryCount(0),
 189       mShuttingDown(false),
 190       mSaveDataRunnableDispatched(false) {
 191   MOZ_ASSERT(NS_IsMainThread());
 192 }
 193
 194 ServiceWorkerRegistrar::~ServiceWorkerRegistrar() {
 195   MOZ_ASSERT(!mSaveDataRunnableDispatched);
 196 }
 197
 198 void ServiceWorkerRegistrar::GetRegistrations(
 199     nsTArray<ServiceWorkerRegistrationData>& aValues) {
 200   MOZ_ASSERT(NS_IsMainThread());
 201   MOZ_ASSERT(aValues.IsEmpty());
 202
 203   MonitorAutoLock lock(mMonitor);
 204
 205   // If we don't have the profile directory, profile is not started yet (and
 206   // probably we are in a utest).
 207   if (!mProfileDir) {
 208     return;
 209   }
 210
 211   // We care just about the first execution because this can be blocked by
 212   // loading data from disk.
 213   static bool firstTime = true;
 214   TimeStamp startTime;
 215
 216   if (firstTime) {
 217     startTime = TimeStamp::NowLoRes();
 218   }
 219
 220   // Waiting for data loaded.
 221   mMonitor.AssertCurrentThreadOwns();
 222   while (!mDataLoaded) {
 223     mMonitor.Wait();
 224   }
 225
 226   aValues.AppendElements(mData);
 227
 228   MaybeResetGeneration();
 229   MOZ_DIAGNOSTIC_ASSERT(mDataGeneration != kInvalidGeneration);
 230   MOZ_DIAGNOSTIC_ASSERT(mFileGeneration != kInvalidGeneration);
 231
 232   if (firstTime) {
 233     firstTime = false;
 234     Telemetry::AccumulateTimeDelta(
 235         Telemetry::SERVICE_WORKER_REGISTRATION_LOADING, startTime);
 236   }
 237 }
 238
 239 namespace {
 240
 241 bool Equivalent(const ServiceWorkerRegistrationData& aLeft,
 242                 const ServiceWorkerRegistrationData& aRight) {
 243   MOZ_ASSERT(aLeft.principal().type() ==
 244              mozilla::ipc::PrincipalInfo::TContentPrincipalInfo);
 245   MOZ_ASSERT(aRight.principal().type() ==
 246              mozilla::ipc::PrincipalInfo::TContentPrincipalInfo);
 247
 248   const auto& leftPrincipal = aLeft.principal().get_ContentPrincipalInfo();
 249   const auto& rightPrincipal = aRight.principal().get_ContentPrincipalInfo();
 250
 251   // Only compare the attributes, not the spec part of the principal.
 252   // The scope comparison above already covers the origin and codebase
 253   // principals include the full path in their spec which is not what
 254   // we want here.
 255   return aLeft.scope() == aRight.scope() &&
 256          leftPrincipal.attrs() == rightPrincipal.attrs();
 257 }
 258
 259 }  // anonymous namespace
 260
 261 void ServiceWorkerRegistrar::RegisterServiceWorker(
 262     const ServiceWorkerRegistrationData& aData) {
 263   AssertIsOnBackgroundThread();
 264
 265   if (mShuttingDown) {
 266     NS_WARNING("Failed to register a serviceWorker during shutting down.");
 267     return;
 268   }
 269
 270   {
 271     MonitorAutoLock lock(mMonitor);
 272     MOZ_ASSERT(mDataLoaded);
 273     RegisterServiceWorkerInternal(aData);
 274   }
 275
 276   MaybeScheduleSaveData();
 277   StorageActivityService::SendActivity(aData.principal());
 278 }
 279
 280 void ServiceWorkerRegistrar::UnregisterServiceWorker(
 281     const PrincipalInfo& aPrincipalInfo, const nsACString& aScope) {
 282   AssertIsOnBackgroundThread();
 283
 284   if (mShuttingDown) {
 285     NS_WARNING("Failed to unregister a serviceWorker during shutting down.");
 286     return;
 287   }
 288
 289   bool deleted = false;
 290
 291   {
 292     MonitorAutoLock lock(mMonitor);
 293     MOZ_ASSERT(mDataLoaded);
 294
 295     ServiceWorkerRegistrationData tmp;
 296     tmp.principal() = aPrincipalInfo;
 297     tmp.scope() = aScope;
 298
 299     for (uint32_t i = 0; i < mData.Length(); ++i) {
 300       if (Equivalent(tmp, mData[i])) {
 301         gServiceWorkersRegistered--;
 302         if (mData[i].currentWorkerHandlesFetch()) {
 303           gServiceWorkersRegisteredFetch--;
 304         }
 305         // Update Telemetry
 306         Telemetry::ScalarSet(Telemetry::ScalarID::SERVICEWORKER_REGISTRATIONS,
 307                              u"All"_ns, gServiceWorkersRegistered);
 308         Telemetry::ScalarSet(Telemetry::ScalarID::SERVICEWORKER_REGISTRATIONS,
 309                              u"Fetch"_ns, gServiceWorkersRegisteredFetch);
 310         LOG(("Unregister ServiceWorker: %u, fetch %u\n",
 311              gServiceWorkersRegistered, gServiceWorkersRegisteredFetch));
 312
 313         mData.RemoveElementAt(i);
 314         mDataGeneration = GetNextGeneration();
 315         deleted = true;
 316         break;
 317       }
 318     }
 319   }
 320
 321   if (deleted) {
 322     MaybeScheduleSaveData();
 323     StorageActivityService::SendActivity(aPrincipalInfo);
 324   }
 325 }
 326
 327 void ServiceWorkerRegistrar::RemoveAll() {
 328   AssertIsOnBackgroundThread();
 329
 330   if (mShuttingDown) {
 331     NS_WARNING("Failed to remove all the serviceWorkers during shutting down.");
 332     return;
 333   }
 334
 335   bool deleted = false;
 336
 337   nsTArray<ServiceWorkerRegistrationData> data;
 338   {
 339     MonitorAutoLock lock(mMonitor);
 340     MOZ_ASSERT(mDataLoaded);
 341
 342     // Let's take a copy in order to inform StorageActivityService.
 343     data = mData.Clone();
 344
 345     deleted = !mData.IsEmpty();
 346     mData.Clear();
 347
 348     mDataGeneration = GetNextGeneration();
 349   }
 350
 351   if (!deleted) {
 352     return;
 353   }
 354
 355   MaybeScheduleSaveData();
 356
 357   for (uint32_t i = 0, len = data.Length(); i < len; ++i) {
 358     StorageActivityService::SendActivity(data[i].principal());
 359   }
 360 }
 361
 362 void ServiceWorkerRegistrar::LoadData() {
 363   MOZ_ASSERT(!NS_IsMainThread());
 364 #ifdef DEBUG
 365   {
 366     MonitorAutoLock lock(mMonitor);
 367     MOZ_ASSERT(!mDataLoaded);
 368   }
 369 #endif
 370
 371   nsresult rv = ReadData();
 372
 373   if (NS_WARN_IF(NS_FAILED(rv))) {
 374     DeleteData();
 375     // Also if the reading failed we have to notify what is waiting for data.
 376   }
 377
 378   MonitorAutoLock lock(mMonitor);
 379   MOZ_ASSERT(!mDataLoaded);
 380   mDataLoaded = true;
 381   mMonitor.Notify();
 382 }
 383
 384 bool ServiceWorkerRegistrar::ReloadDataForTest() {
 385   if (NS_WARN_IF(!StaticPrefs::dom_serviceWorkers_testing_enabled())) {
 386     return false;
 387   }
 388
 389   MOZ_ASSERT(NS_IsMainThread());
 390   MonitorAutoLock lock(mMonitor);
 391   mData.Clear();
 392   mDataLoaded = false;
 393
 394   nsCOMPtr<nsIEventTarget> target =
 395       do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
 396   MOZ_ASSERT(target, "Must have stream transport service");
 397
 398   nsCOMPtr<nsIRunnable> runnable =
 399       NewRunnableMethod("dom::ServiceWorkerRegistrar::LoadData", this,
 400                         &ServiceWorkerRegistrar::LoadData);
 401   nsresult rv = target->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
 402   if (NS_FAILED(rv)) {
 403     NS_WARNING("Failed to dispatch the LoadDataRunnable.");
 404     return false;
 405   }
 406
 407   mMonitor.AssertCurrentThreadOwns();
 408   while (!mDataLoaded) {
 409     mMonitor.Wait();
 410   }
 411
 412   return mDataLoaded;
 413 }
 414
 415 nsresult ServiceWorkerRegistrar::ReadData() {
 416   // We cannot assert about the correct thread because normally this method
 417   // runs on a IO thread, but in gTests we call it from the main-thread.
 418
 419   nsCOMPtr<nsIFile> file;
 420
 421   {
 422     MonitorAutoLock lock(mMonitor);
 423
 424     if (!mProfileDir) {
 425       return NS_ERROR_FAILURE;
 426     }
 427
 428     nsresult rv = mProfileDir->Clone(getter_AddRefs(file));
 429     if (NS_WARN_IF(NS_FAILED(rv))) {
 430       return rv;
 431     }
 432   }
 433
 434   nsresult rv = file->Append(nsLiteralString(SERVICEWORKERREGISTRAR_FILE));
 435   if (NS_WARN_IF(NS_FAILED(rv))) {
 436     return rv;
 437   }
 438
 439   bool exists;
 440   rv = file->Exists(&exists);
 441   if (NS_WARN_IF(NS_FAILED(rv))) {
 442     return rv;
 443   }
 444
 445   if (!exists) {
 446     return NS_OK;
 447   }
 448
 449   nsCOMPtr<nsIInputStream> stream;
 450   rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file);
 451   if (NS_WARN_IF(NS_FAILED(rv))) {
 452     return rv;
 453   }
 454
 455   nsCOMPtr<nsILineInputStream> lineInputStream = do_QueryInterface(stream);
 456   MOZ_ASSERT(lineInputStream);
 457
 458   nsAutoCString version;
 459   bool hasMoreLines;
 460   rv = lineInputStream->ReadLine(version, &hasMoreLines);
 461   if (NS_WARN_IF(NS_FAILED(rv))) {
 462     return rv;
 463   }
 464
 465   if (!IsSupportedVersion(version)) {
 466     nsContentUtils::LogMessageToConsole(
 467         nsPrintfCString("Unsupported service worker registrar version: %s",
 468                         version.get())
 469             .get());
 470     return NS_ERROR_FAILURE;
 471   }
 472
 473   nsTArray<ServiceWorkerRegistrationData> tmpData;
 474
 475   bool overwrite = false;
 476   bool dedupe = false;
 477   while (hasMoreLines) {
 478     ServiceWorkerRegistrationData* entry = tmpData.AppendElement();
 479
 480 #define GET_LINE(x)                                 \
 481   rv = lineInputStream->ReadLine(x, &hasMoreLines); \
 482   if (NS_WARN_IF(NS_FAILED(rv))) {                  \
 483     return rv;                                      \
 484   }                                                 \
 485   if (NS_WARN_IF(!hasMoreLines)) {                  \
 486     return NS_ERROR_FAILURE;                        \
 487   }
 488
 489     nsAutoCString line;
 490     if (version.EqualsLiteral(SERVICEWORKERREGISTRAR_VERSION)) {
 491       rv = CreatePrincipalInfo(lineInputStream, entry);
 492       if (NS_WARN_IF(NS_FAILED(rv))) {
 493         return rv;
 494       }
 495
 496       GET_LINE(entry->currentWorkerURL());
 497
 498       nsAutoCString fetchFlag;
 499       GET_LINE(fetchFlag);
 500       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
 501           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
 502         return NS_ERROR_INVALID_ARG;
 503       }
 504       entry->currentWorkerHandlesFetch() =
 505           fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE);
 506
 507       nsAutoCString cacheName;
 508       GET_LINE(cacheName);
 509       CopyUTF8toUTF16(cacheName, entry->cacheName());
 510
 511       nsAutoCString updateViaCache;
 512       GET_LINE(updateViaCache);
 513       entry->updateViaCache() = updateViaCache.ToInteger(&rv, 16);
 514       if (NS_WARN_IF(NS_FAILED(rv))) {
 515         return rv;
 516       }
 517       if (entry->updateViaCache() >
 518           nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_NONE) {
 519         return NS_ERROR_INVALID_ARG;
 520       }
 521
 522       nsAutoCString installedTimeStr;
 523       GET_LINE(installedTimeStr);
 524       int64_t installedTime = installedTimeStr.ToInteger64(&rv);
 525       if (NS_WARN_IF(NS_FAILED(rv))) {
 526         return rv;
 527       }
 528       entry->currentWorkerInstalledTime() = installedTime;
 529
 530       nsAutoCString activatedTimeStr;
 531       GET_LINE(activatedTimeStr);
 532       int64_t activatedTime = activatedTimeStr.ToInteger64(&rv);
 533       if (NS_WARN_IF(NS_FAILED(rv))) {
 534         return rv;
 535       }
 536       entry->currentWorkerActivatedTime() = activatedTime;
 537
 538       nsAutoCString lastUpdateTimeStr;
 539       GET_LINE(lastUpdateTimeStr);
 540       int64_t lastUpdateTime = lastUpdateTimeStr.ToInteger64(&rv);
 541       if (NS_WARN_IF(NS_FAILED(rv))) {
 542         return rv;
 543       }
 544       entry->lastUpdateTime() = lastUpdateTime;
 545
 546       nsAutoCString navigationPreloadEnabledStr;
 547       GET_LINE(navigationPreloadEnabledStr);
 548       bool navigationPreloadEnabled =
 549           navigationPreloadEnabledStr.ToInteger(&rv);
 550       if (NS_WARN_IF(NS_FAILED(rv))) {
 551         return rv;
 552       }
 553       entry->navigationPreloadState().enabled() = navigationPreloadEnabled;
 554
 555       GET_LINE(entry->navigationPreloadState().headerValue());
 556     } else if (version.EqualsLiteral("8")) {
 557       rv = CreatePrincipalInfo(lineInputStream, entry);
 558       if (NS_WARN_IF(NS_FAILED(rv))) {
 559         return rv;
 560       }
 561
 562       GET_LINE(entry->currentWorkerURL());
 563
 564       nsAutoCString fetchFlag;
 565       GET_LINE(fetchFlag);
 566       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
 567           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
 568         return NS_ERROR_INVALID_ARG;
 569       }
 570       entry->currentWorkerHandlesFetch() =
 571           fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE);
 572
 573       nsAutoCString cacheName;
 574       GET_LINE(cacheName);
 575       CopyUTF8toUTF16(cacheName, entry->cacheName());
 576
 577       nsAutoCString updateViaCache;
 578       GET_LINE(updateViaCache);
 579       entry->updateViaCache() = updateViaCache.ToInteger(&rv, 16);
 580       if (NS_WARN_IF(NS_FAILED(rv))) {
 581         return rv;
 582       }
 583       if (entry->updateViaCache() >
 584           nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_NONE) {
 585         return NS_ERROR_INVALID_ARG;
 586       }
 587
 588       nsAutoCString installedTimeStr;
 589       GET_LINE(installedTimeStr);
 590       int64_t installedTime = installedTimeStr.ToInteger64(&rv);
 591       if (NS_WARN_IF(NS_FAILED(rv))) {
 592         return rv;
 593       }
 594       entry->currentWorkerInstalledTime() = installedTime;
 595
 596       nsAutoCString activatedTimeStr;
 597       GET_LINE(activatedTimeStr);
 598       int64_t activatedTime = activatedTimeStr.ToInteger64(&rv);
 599       if (NS_WARN_IF(NS_FAILED(rv))) {
 600         return rv;
 601       }
 602       entry->currentWorkerActivatedTime() = activatedTime;
 603
 604       nsAutoCString lastUpdateTimeStr;
 605       GET_LINE(lastUpdateTimeStr);
 606       int64_t lastUpdateTime = lastUpdateTimeStr.ToInteger64(&rv);
 607       if (NS_WARN_IF(NS_FAILED(rv))) {
 608         return rv;
 609       }
 610       entry->lastUpdateTime() = lastUpdateTime;
 611
 612       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 613     } else if (version.EqualsLiteral("7")) {
 614       rv = CreatePrincipalInfo(lineInputStream, entry);
 615       if (NS_WARN_IF(NS_FAILED(rv))) {
 616         return rv;
 617       }
 618
 619       GET_LINE(entry->currentWorkerURL());
 620
 621       nsAutoCString fetchFlag;
 622       GET_LINE(fetchFlag);
 623       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
 624           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
 625         return NS_ERROR_INVALID_ARG;
 626       }
 627       entry->currentWorkerHandlesFetch() =
 628           fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE);
 629
 630       nsAutoCString cacheName;
 631       GET_LINE(cacheName);
 632       CopyUTF8toUTF16(cacheName, entry->cacheName());
 633
 634       nsAutoCString loadFlags;
 635       GET_LINE(loadFlags);
 636       entry->updateViaCache() =
 637           loadFlags.ToInteger(&rv, 16) == nsIRequest::LOAD_NORMAL
 638               ? nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_ALL
 639               : nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS;
 640
 641       if (NS_WARN_IF(NS_FAILED(rv))) {
 642         return rv;
 643       }
 644
 645       nsAutoCString installedTimeStr;
 646       GET_LINE(installedTimeStr);
 647       int64_t installedTime = installedTimeStr.ToInteger64(&rv);
 648       if (NS_WARN_IF(NS_FAILED(rv))) {
 649         return rv;
 650       }
 651       entry->currentWorkerInstalledTime() = installedTime;
 652
 653       nsAutoCString activatedTimeStr;
 654       GET_LINE(activatedTimeStr);
 655       int64_t activatedTime = activatedTimeStr.ToInteger64(&rv);
 656       if (NS_WARN_IF(NS_FAILED(rv))) {
 657         return rv;
 658       }
 659       entry->currentWorkerActivatedTime() = activatedTime;
 660
 661       nsAutoCString lastUpdateTimeStr;
 662       GET_LINE(lastUpdateTimeStr);
 663       int64_t lastUpdateTime = lastUpdateTimeStr.ToInteger64(&rv);
 664       if (NS_WARN_IF(NS_FAILED(rv))) {
 665         return rv;
 666       }
 667       entry->lastUpdateTime() = lastUpdateTime;
 668
 669       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 670     } else if (version.EqualsLiteral("6")) {
 671       rv = CreatePrincipalInfo(lineInputStream, entry);
 672       if (NS_WARN_IF(NS_FAILED(rv))) {
 673         return rv;
 674       }
 675
 676       GET_LINE(entry->currentWorkerURL());
 677
 678       nsAutoCString fetchFlag;
 679       GET_LINE(fetchFlag);
 680       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
 681           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
 682         return NS_ERROR_INVALID_ARG;
 683       }
 684       entry->currentWorkerHandlesFetch() =
 685           fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE);
 686
 687       nsAutoCString cacheName;
 688       GET_LINE(cacheName);
 689       CopyUTF8toUTF16(cacheName, entry->cacheName());
 690
 691       nsAutoCString loadFlags;
 692       GET_LINE(loadFlags);
 693       entry->updateViaCache() =
 694           loadFlags.ToInteger(&rv, 16) == nsIRequest::LOAD_NORMAL
 695               ? nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_ALL
 696               : nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS;
 697
 698       if (NS_WARN_IF(NS_FAILED(rv))) {
 699         return rv;
 700       }
 701
 702       entry->currentWorkerInstalledTime() = 0;
 703       entry->currentWorkerActivatedTime() = 0;
 704       entry->lastUpdateTime() = 0;
 705
 706       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 707     } else if (version.EqualsLiteral("5")) {
 708       overwrite = true;
 709       dedupe = true;
 710
 711       rv = CreatePrincipalInfo(lineInputStream, entry);
 712       if (NS_WARN_IF(NS_FAILED(rv))) {
 713         return rv;
 714       }
 715
 716       GET_LINE(entry->currentWorkerURL());
 717
 718       nsAutoCString fetchFlag;
 719       GET_LINE(fetchFlag);
 720       if (!fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE) &&
 721           !fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_FALSE)) {
 722         return NS_ERROR_INVALID_ARG;
 723       }
 724       entry->currentWorkerHandlesFetch() =
 725           fetchFlag.EqualsLiteral(SERVICEWORKERREGISTRAR_TRUE);
 726
 727       nsAutoCString cacheName;
 728       GET_LINE(cacheName);
 729       CopyUTF8toUTF16(cacheName, entry->cacheName());
 730
 731       entry->updateViaCache() =
 732           nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS;
 733
 734       entry->currentWorkerInstalledTime() = 0;
 735       entry->currentWorkerActivatedTime() = 0;
 736       entry->lastUpdateTime() = 0;
 737
 738       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 739     } else if (version.EqualsLiteral("4")) {
 740       overwrite = true;
 741       dedupe = true;
 742
 743       rv = CreatePrincipalInfo(lineInputStream, entry);
 744       if (NS_WARN_IF(NS_FAILED(rv))) {
 745         return rv;
 746       }
 747
 748       GET_LINE(entry->currentWorkerURL());
 749
 750       // default handlesFetch flag to Enabled
 751       entry->currentWorkerHandlesFetch() = true;
 752
 753       nsAutoCString cacheName;
 754       GET_LINE(cacheName);
 755       CopyUTF8toUTF16(cacheName, entry->cacheName());
 756
 757       entry->updateViaCache() =
 758           nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS;
 759
 760       entry->currentWorkerInstalledTime() = 0;
 761       entry->currentWorkerActivatedTime() = 0;
 762       entry->lastUpdateTime() = 0;
 763
 764       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 765     } else if (version.EqualsLiteral("3")) {
 766       overwrite = true;
 767       dedupe = true;
 768
 769       rv = CreatePrincipalInfo(lineInputStream, entry, true);
 770       if (NS_WARN_IF(NS_FAILED(rv))) {
 771         return rv;
 772       }
 773
 774       GET_LINE(entry->currentWorkerURL());
 775
 776       // default handlesFetch flag to Enabled
 777       entry->currentWorkerHandlesFetch() = true;
 778
 779       nsAutoCString cacheName;
 780       GET_LINE(cacheName);
 781       CopyUTF8toUTF16(cacheName, entry->cacheName());
 782
 783       entry->updateViaCache() =
 784           nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS;
 785
 786       entry->currentWorkerInstalledTime() = 0;
 787       entry->currentWorkerActivatedTime() = 0;
 788       entry->lastUpdateTime() = 0;
 789
 790       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 791     } else if (version.EqualsLiteral("2")) {
 792       overwrite = true;
 793       dedupe = true;
 794
 795       rv = CreatePrincipalInfo(lineInputStream, entry, true);
 796       if (NS_WARN_IF(NS_FAILED(rv))) {
 797         return rv;
 798       }
 799
 800       // scriptSpec is no more used in latest version.
 801       nsAutoCString unused;
 802       GET_LINE(unused);
 803
 804       GET_LINE(entry->currentWorkerURL());
 805
 806       // default handlesFetch flag to Enabled
 807       entry->currentWorkerHandlesFetch() = true;
 808
 809       nsAutoCString cacheName;
 810       GET_LINE(cacheName);
 811       CopyUTF8toUTF16(cacheName, entry->cacheName());
 812
 813       // waitingCacheName is no more used in latest version.
 814       GET_LINE(unused);
 815
 816       entry->updateViaCache() =
 817           nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS;
 818
 819       entry->currentWorkerInstalledTime() = 0;
 820       entry->currentWorkerActivatedTime() = 0;
 821       entry->lastUpdateTime() = 0;
 822
 823       entry->navigationPreloadState() = gDefaultNavigationPreloadState;
 824     } else {
 825       MOZ_ASSERT_UNREACHABLE("Should never get here!");
 826     }
 827
 828 #undef GET_LINE
 829
 830     rv = lineInputStream->ReadLine(line, &hasMoreLines);
 831     if (NS_WARN_IF(NS_FAILED(rv))) {
 832       return rv;
 833     }
 834
 835     if (!line.EqualsLiteral(SERVICEWORKERREGISTRAR_TERMINATOR)) {
 836       return NS_ERROR_FAILURE;
 837     }
 838   }
 839
 840   stream->Close();
 841
 842   // We currently only call this at startup where we block the main thread
 843   // preventing further operation until it completes, however take the lock
 844   // in case that changes
 845
 846   {
 847     MonitorAutoLock lock(mMonitor);
 848     // Copy data over to mData.
 849     for (uint32_t i = 0; i < tmpData.Length(); ++i) {
 850       // Older versions could sometimes write out empty, useless entries.
 851       // Prune those here.
 852       if (!ServiceWorkerRegistrationDataIsValid(tmpData[i])) {
 853         continue;
 854       }
 855
 856       bool match = false;
 857       if (dedupe) {
 858         MOZ_ASSERT(overwrite);
 859         // If this is an old profile, then we might need to deduplicate.  In
 860         // theory this can be removed in the future (Bug 1248449)
 861         for (uint32_t j = 0; j < mData.Length(); ++j) {
 862           // Use same comparison as RegisterServiceWorker. Scope contains
 863           // basic origin information.  Combine with any principal attributes.
 864           if (Equivalent(tmpData[i], mData[j])) {
 865             // Last match wins, just like legacy loading used to do in
 866             // the ServiceWorkerManager.
 867             mData[j] = tmpData[i];
 868             // Dupe found, so overwrite file with reduced list.
 869             match = true;
 870             break;
 871           }
 872         }
 873       } else {
 874 #ifdef DEBUG
 875         // Otherwise assert no duplications in debug builds.
 876         for (uint32_t j = 0; j < mData.Length(); ++j) {
 877           MOZ_ASSERT(!Equivalent(tmpData[i], mData[j]));
 878         }
 879 #endif
 880       }
 881       if (!match) {
 882         mData.AppendElement(tmpData[i]);
 883       }
 884     }
 885   }
 886   // Overwrite previous version.
 887   // Cannot call SaveData directly because gtest uses main-thread.
 888
 889   // XXX NOTE: if we could be accessed multi-threaded here, we would need to
 890   // find a way to lock around access to mData.  Since we can't, suppress the
 891   // thread-safety warnings.
 892   MOZ_PUSH_IGNORE_THREAD_SAFETY
 893   if (overwrite && NS_FAILED(WriteData(mData))) {
 894     NS_WARNING("Failed to write data for the ServiceWorker Registations.");
 895     DeleteData();
 896   }
 897   MOZ_POP_THREAD_SAFETY
 898
 899   return NS_OK;
 900 }
 901
 902 void ServiceWorkerRegistrar::DeleteData() {
 903   // We cannot assert about the correct thread because normally this method
 904   // runs on a IO thread, but in gTests we call it from the main-thread.
 905
 906   nsCOMPtr<nsIFile> file;
 907
 908   {
 909     MonitorAutoLock lock(mMonitor);
 910     mData.Clear();
 911
 912     if (!mProfileDir) {
 913       return;
 914     }
 915
 916     nsresult rv = mProfileDir->Clone(getter_AddRefs(file));
 917     if (NS_WARN_IF(NS_FAILED(rv))) {
 918       return;
 919     }
 920   }
 921
 922   nsresult rv = file->Append(nsLiteralString(SERVICEWORKERREGISTRAR_FILE));
 923   if (NS_WARN_IF(NS_FAILED(rv))) {
 924     return;
 925   }
 926
 927   rv = file->Remove(false);
 928   if (rv == NS_ERROR_FILE_NOT_FOUND) {
 929     return;
 930   }
 931
 932   if (NS_WARN_IF(NS_FAILED(rv))) {
 933     return;
 934   }
 935 }
 936
 937 void ServiceWorkerRegistrar::RegisterServiceWorkerInternal(
 938     const ServiceWorkerRegistrationData& aData) {
 939   bool found = false;
 940   for (uint32_t i = 0, len = mData.Length(); i < len; ++i) {
 941     if (Equivalent(aData, mData[i])) {
 942       found = true;
 943       if (mData[i].currentWorkerHandlesFetch()) {
 944         // Decrement here if we found it, in case the new registration no
 945         // longer handles Fetch.  If it continues to handle fetch, we'll
 946         // bump it back later.
 947         gServiceWorkersRegisteredFetch--;
 948       }
 949       mData[i] = aData;
 950       break;
 951     }
 952   }
 953
 954   if (!found) {
 955     MOZ_ASSERT(ServiceWorkerRegistrationDataIsValid(aData));
 956     mData.AppendElement(aData);
 957     // We didn't find an entry to update, so we have 1 more
 958     gServiceWorkersRegistered++;
 959   }
 960   // Handles bumping both for new registrations and updates
 961   if (aData.currentWorkerHandlesFetch()) {
 962     gServiceWorkersRegisteredFetch++;
 963   }
 964   // Update Telemetry
 965   Telemetry::ScalarSet(Telemetry::ScalarID::SERVICEWORKER_REGISTRATIONS,
 966                        u"All"_ns, gServiceWorkersRegistered);
 967   Telemetry::ScalarSet(Telemetry::ScalarID::SERVICEWORKER_REGISTRATIONS,
 968                        u"Fetch"_ns, gServiceWorkersRegisteredFetch);
 969   LOG(("Register: %u, fetch %u\n", gServiceWorkersRegistered,
 970        gServiceWorkersRegisteredFetch));
 971
 972   mDataGeneration = GetNextGeneration();
 973 }
 974
 975 class ServiceWorkerRegistrarSaveDataRunnable final : public Runnable {
 976   nsCOMPtr<nsIEventTarget> mEventTarget;
 977   const nsTArray<ServiceWorkerRegistrationData> mData;
 978   const uint32_t mGeneration;
 979
 980  public:
 981   ServiceWorkerRegistrarSaveDataRunnable(
 982       nsTArray<ServiceWorkerRegistrationData>&& aData, uint32_t aGeneration)
 983       : Runnable("dom::ServiceWorkerRegistrarSaveDataRunnable"),
 984         mEventTarget(GetCurrentSerialEventTarget()),
 985         mData(std::move(aData)),
 986         mGeneration(aGeneration) {
 987     AssertIsOnBackgroundThread();
 988     MOZ_DIAGNOSTIC_ASSERT(mGeneration != kInvalidGeneration);
 989   }
 990
 991   NS_IMETHOD
 992   Run() override {
 993     RefPtr<ServiceWorkerRegistrar> service = ServiceWorkerRegistrar::Get();
 994     MOZ_ASSERT(service);
 995
 996     uint32_t fileGeneration = kInvalidGeneration;
 997
 998     if (NS_SUCCEEDED(service->SaveData(mData))) {
 999       fileGeneration = mGeneration;
1000     }
1001
1002     RefPtr<Runnable> runnable = NewRunnableMethod<uint32_t>(
1003         "ServiceWorkerRegistrar::DataSaved", service,
1004         &ServiceWorkerRegistrar::DataSaved, fileGeneration);
1005     MOZ_ALWAYS_SUCCEEDS(
1006         mEventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL));
1007
1008     return NS_OK;
1009   }
1010 };
1011
1012 void ServiceWorkerRegistrar::MaybeScheduleSaveData() {
1013   AssertIsOnBackgroundThread();
1014   MOZ_ASSERT(!mShuttingDown);
1015
1016   if (mShuttingDown || mSaveDataRunnableDispatched ||
1017       mDataGeneration <= mFileGeneration) {
1018     return;
1019   }
1020
1021   nsCOMPtr<nsIEventTarget> target =
1022       do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
1023   MOZ_ASSERT(target, "Must have stream transport service");
1024
1025   uint32_t generation = kInvalidGeneration;
1026   nsTArray<ServiceWorkerRegistrationData> data;
1027
1028   {
1029     MonitorAutoLock lock(mMonitor);
1030     generation = mDataGeneration;
1031     data.AppendElements(mData);
1032   }
1033
1034   RefPtr<Runnable> runnable =
1035       new ServiceWorkerRegistrarSaveDataRunnable(std::move(data), generation);
1036   nsresult rv = target->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
1037   NS_ENSURE_SUCCESS_VOID(rv);
1038
1039   mSaveDataRunnableDispatched = true;
1040 }
1041
1042 void ServiceWorkerRegistrar::ShutdownCompleted() {
1043   MOZ_ASSERT(NS_IsMainThread());
1044
1045   DebugOnly<nsresult> rv = GetShutdownPhase()->RemoveBlocker(this);
1046   MOZ_ASSERT(NS_SUCCEEDED(rv));
1047 }
1048
1049 nsresult ServiceWorkerRegistrar::SaveData(
1050     const nsTArray<ServiceWorkerRegistrationData>& aData) {
1051   MOZ_ASSERT(!NS_IsMainThread());
1052
1053   nsresult rv = WriteData(aData);
1054   if (NS_FAILED(rv)) {
1055     NS_WARNING("Failed to write data for the ServiceWorker Registations.");
1056     // Don't touch the file or in-memory state.  Writing files can
1057     // sometimes fail due to virus scanning, etc.  We should just leave
1058     // things as is so the next save operation can pick up any changes
1059     // without losing data.
1060   }
1061   return rv;
1062 }
1063
1064 void ServiceWorkerRegistrar::DataSaved(uint32_t aFileGeneration) {
1065   AssertIsOnBackgroundThread();
1066   MOZ_ASSERT(mSaveDataRunnableDispatched);
1067
1068   mSaveDataRunnableDispatched = false;
1069
1070   // Check for shutdown before possibly triggering any more saves
1071   // runnables.
1072   MaybeScheduleShutdownCompleted();
1073   if (mShuttingDown) {
1074     return;
1075   }
1076
1077   // If we got a valid generation, then the save was successful.
1078   if (aFileGeneration != kInvalidGeneration) {
1079     // Update the file generation.  We also check to see if we
1080     // can reset the generation back to zero if the file and data
1081     // are now in sync.  This allows us to avoid dealing with wrap
1082     // around of the generation count.
1083     mFileGeneration = aFileGeneration;
1084     MaybeResetGeneration();
1085
1086     // Successful write resets the retry count.
1087     mRetryCount = 0;
1088
1089     // Possibly schedule another save operation if more data
1090     // has come in while processing this one.
1091     MaybeScheduleSaveData();
1092
1093     return;
1094   }
1095
1096   // Otherwise, the save failed since the generation is invalid.  We
1097   // want to retry the save, but only a limited number of times.
1098   static const uint32_t kMaxRetryCount = 2;
1099   if (mRetryCount >= kMaxRetryCount) {
1100     return;
1101   }
1102
1103   mRetryCount += 1;
1104   MaybeScheduleSaveData();
1105 }
1106
1107 void ServiceWorkerRegistrar::MaybeScheduleShutdownCompleted() {
1108   AssertIsOnBackgroundThread();
1109
1110   if (mSaveDataRunnableDispatched || !mShuttingDown) {
1111     return;
1112   }
1113
1114   RefPtr<Runnable> runnable =
1115       NewRunnableMethod("dom::ServiceWorkerRegistrar::ShutdownCompleted", this,
1116                         &ServiceWorkerRegistrar::ShutdownCompleted);
1117   MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable.forget()));
1118 }
1119
1120 uint32_t ServiceWorkerRegistrar::GetNextGeneration() {
1121   uint32_t ret = mDataGeneration + 1;
1122   if (ret == kInvalidGeneration) {
1123     ret += 1;
1124   }
1125   return ret;
1126 }
1127
1128 void ServiceWorkerRegistrar::MaybeResetGeneration() {
1129   if (mDataGeneration != mFileGeneration) {
1130     return;
1131   }
1132   mDataGeneration = mFileGeneration = 0;
1133 }
1134
1135 bool ServiceWorkerRegistrar::IsSupportedVersion(
1136     const nsACString& aVersion) const {
1137   uint32_t numVersions = ArrayLength(gSupportedRegistrarVersions);
1138   for (uint32_t i = 0; i < numVersions; i++) {
1139     if (aVersion.EqualsASCII(gSupportedRegistrarVersions[i])) {
1140       return true;
1141     }
1142   }
1143   return false;
1144 }
1145
1146 nsresult ServiceWorkerRegistrar::WriteData(
1147     const nsTArray<ServiceWorkerRegistrationData>& aData) {
1148   // We cannot assert about the correct thread because normally this method
1149   // runs on a IO thread, but in gTests we call it from the main-thread.
1150
1151   nsCOMPtr<nsIFile> file;
1152
1153   {
1154     MonitorAutoLock lock(mMonitor);
1155
1156     if (!mProfileDir) {
1157       return NS_ERROR_FAILURE;
1158     }
1159
1160     nsresult rv = mProfileDir->Clone(getter_AddRefs(file));
1161     if (NS_WARN_IF(NS_FAILED(rv))) {
1162       return rv;
1163     }
1164   }
1165
1166   nsresult rv = file->Append(nsLiteralString(SERVICEWORKERREGISTRAR_FILE));
1167   if (NS_WARN_IF(NS_FAILED(rv))) {
1168     return rv;
1169   }
1170
1171   nsCOMPtr<nsIOutputStream> stream;
1172   rv = NS_NewSafeLocalFileOutputStream(getter_AddRefs(stream), file);
1173   if (NS_WARN_IF(NS_FAILED(rv))) {
1174     return rv;
1175   }
1176
1177   nsAutoCString buffer;
1178   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_VERSION);
1179   buffer.Append('\n');
1180
1181   uint32_t count;
1182   rv = stream->Write(buffer.Data(), buffer.Length(), &count);
1183   if (NS_WARN_IF(NS_FAILED(rv))) {
1184     return rv;
1185   }
1186
1187   if (count != buffer.Length()) {
1188     return NS_ERROR_UNEXPECTED;
1189   }
1190
1191   for (uint32_t i = 0, len = aData.Length(); i < len; ++i) {
1192     // We have an assertion further up the stack, but as a last
1193     // resort avoid writing out broken entries here.
1194     if (!ServiceWorkerRegistrationDataIsValid(aData[i])) {
1195       continue;
1196     }
1197
1198     const mozilla::ipc::PrincipalInfo& info = aData[i].principal();
1199
1200     MOZ_ASSERT(info.type() ==
1201                mozilla::ipc::PrincipalInfo::TContentPrincipalInfo);
1202
1203     const mozilla::ipc::ContentPrincipalInfo& cInfo =
1204         info.get_ContentPrincipalInfo();
1205
1206     nsAutoCString suffix;
1207     cInfo.attrs().CreateSuffix(suffix);
1208
1209     buffer.Truncate();
1210     buffer.Append(suffix.get());
1211     buffer.Append('\n');
1212
1213     buffer.Append(aData[i].scope());
1214     buffer.Append('\n');
1215
1216     buffer.Append(aData[i].currentWorkerURL());
1217     buffer.Append('\n');
1218
1219     buffer.Append(aData[i].currentWorkerHandlesFetch()
1220                       ? SERVICEWORKERREGISTRAR_TRUE
1221                       : SERVICEWORKERREGISTRAR_FALSE);
1222     buffer.Append('\n');
1223
1224     buffer.Append(NS_ConvertUTF16toUTF8(aData[i].cacheName()));
1225     buffer.Append('\n');
1226
1227     buffer.AppendInt(aData[i].updateViaCache(), 16);
1228     buffer.Append('\n');
1229     MOZ_DIAGNOSTIC_ASSERT(
1230         aData[i].updateViaCache() ==
1231             nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS ||
1232         aData[i].updateViaCache() ==
1233             nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_ALL ||
1234         aData[i].updateViaCache() ==
1235             nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_NONE);
1236
1237     static_assert(nsIRequest::LOAD_NORMAL == 0,
1238                   "LOAD_NORMAL matches serialized value.");
1239     static_assert(nsIRequest::VALIDATE_ALWAYS == (1 << 11),
1240                   "VALIDATE_ALWAYS matches serialized value");
1241
1242     buffer.AppendInt(aData[i].currentWorkerInstalledTime());
1243     buffer.Append('\n');
1244
1245     buffer.AppendInt(aData[i].currentWorkerActivatedTime());
1246     buffer.Append('\n');
1247
1248     buffer.AppendInt(aData[i].lastUpdateTime());
1249     buffer.Append('\n');
1250
1251     buffer.AppendInt(
1252         static_cast<int32_t>(aData[i].navigationPreloadState().enabled()));
1253     buffer.Append('\n');
1254
1255     buffer.Append(aData[i].navigationPreloadState().headerValue());
1256     buffer.Append('\n');
1257
1258     buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR);
1259     buffer.Append('\n');
1260
1261     rv = stream->Write(buffer.Data(), buffer.Length(), &count);
1262     if (NS_WARN_IF(NS_FAILED(rv))) {
1263       return rv;
1264     }
1265
1266     if (count != buffer.Length()) {
1267       return NS_ERROR_UNEXPECTED;
1268     }
1269   }
1270
1271   nsCOMPtr<nsISafeOutputStream> safeStream = do_QueryInterface(stream);
1272   MOZ_ASSERT(safeStream);
1273
1274   rv = safeStream->Finish();
1275   if (NS_WARN_IF(NS_FAILED(rv))) {
1276     return rv;
1277   }
1278
1279   return NS_OK;
1280 }
1281
1282 void ServiceWorkerRegistrar::ProfileStarted() {
1283   MOZ_ASSERT(NS_IsMainThread());
1284
1285   MonitorAutoLock lock(mMonitor);
1286   MOZ_DIAGNOSTIC_ASSERT(!mProfileDir);
1287
1288   nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
1289                                        getter_AddRefs(mProfileDir));
1290   if (NS_WARN_IF(NS_FAILED(rv))) {
1291     return;
1292   }
1293
1294   nsAutoString blockerName;
1295   MOZ_ALWAYS_SUCCEEDS(GetName(blockerName));
1296
1297   rv = GetShutdownPhase()->AddBlocker(
1298       this, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__, blockerName);
1299   if (NS_WARN_IF(NS_FAILED(rv))) {
1300     return;
1301   }
1302
1303   nsCOMPtr<nsIEventTarget> target =
1304       do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
1305   MOZ_ASSERT(target, "Must have stream transport service");
1306
1307   nsCOMPtr<nsIRunnable> runnable =
1308       NewRunnableMethod("dom::ServiceWorkerRegistrar::LoadData", this,
1309                         &ServiceWorkerRegistrar::LoadData);
1310   rv = target->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
1311   if (NS_FAILED(rv)) {
1312     NS_WARNING("Failed to dispatch the LoadDataRunnable.");
1313   }
1314 }
1315
1316 void ServiceWorkerRegistrar::ProfileStopped() {
1317   MOZ_ASSERT(NS_IsMainThread());
1318
1319   MonitorAutoLock lock(mMonitor);
1320
1321   if (!mProfileDir) {
1322     nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
1323                                          getter_AddRefs(mProfileDir));
1324     if (NS_WARN_IF(NS_FAILED(rv))) {
1325       // If we do not have a profile directory, we are somehow screwed.
1326       MOZ_DIAGNOSTIC_ASSERT(
1327           false,
1328           "NS_GetSpecialDirectory for NS_APP_USER_PROFILE_50_DIR failed!");
1329     }
1330   }
1331
1332   // Mutations to the ServiceWorkerRegistrar happen on the PBackground thread,
1333   // issued by the ServiceWorkerManagerService, so the appropriate place to
1334   // trigger shutdown is on that thread.
1335   //
1336   // However, it's quite possible that the PBackground thread was not brought
1337   // into existence for xpcshell tests.  We don't cause it to be created
1338   // ourselves for any reason, for example.
1339   //
1340   // In this scenario, we know that:
1341   // - We will receive exactly one call to ourself from BlockShutdown() and
1342   //   BlockShutdown() will be called (at most) once.
1343   // - The only way our Shutdown() method gets called is via
1344   //   BackgroundParentImpl::RecvShutdownServiceWorkerRegistrar() being
1345   //   invoked, which only happens if we get to that send below here that we
1346   //   can't get to.
1347   // - All Shutdown() does is set mShuttingDown=true (essential for
1348   //   invariants) and invoke MaybeScheduleShutdownCompleted().
1349   // - Since there is no PBackground thread, mSaveDataRunnableDispatched must
1350   //   be false because only MaybeScheduleSaveData() set it and it only runs
1351   //   on the background thread, so it cannot have run.  And so we would
1352   //   expect MaybeScheduleShutdownCompleted() to schedule an invocation of
1353   //   ShutdownCompleted on the main thread.
1354   PBackgroundChild* child = BackgroundChild::GetForCurrentThread();
1355   if (mProfileDir && child) {
1356     if (child->SendShutdownServiceWorkerRegistrar()) {
1357       // Normal shutdown sequence has been initiated, go home.
1358       return;
1359     }
1360     // If we get here, the PBackground thread has probably gone nuts and we
1361     // want to know it.
1362     MOZ_DIAGNOSTIC_ASSERT(
1363         false, "Unable to send the ShutdownServiceWorkerRegistrar message.");
1364   }
1365
1366   // On any error it's appropriate to set mShuttingDown=true (as Shutdown
1367   // would do) and directly invoke ShutdownCompleted() (as Shutdown would
1368   // indirectly do via MaybeScheduleShutdownCompleted) in order to unblock
1369   // shutdown.
1370   mShuttingDown = true;
1371   ShutdownCompleted();
1372 }
1373
1374 // Async shutdown blocker methods
1375
1376 NS_IMETHODIMP
1377 ServiceWorkerRegistrar::BlockShutdown(nsIAsyncShutdownClient* aClient) {
1378   ProfileStopped();
1379   return NS_OK;
1380 }
1381
1382 NS_IMETHODIMP
1383 ServiceWorkerRegistrar::GetName(nsAString& aName) {
1384   aName = u"ServiceWorkerRegistrar: Flushing data"_ns;
1385   return NS_OK;
1386 }
1387
1388 NS_IMETHODIMP
1389 ServiceWorkerRegistrar::GetState(nsIPropertyBag** aBagOut) {
1390   nsCOMPtr<nsIWritablePropertyBag2> propertyBag =
1391       do_CreateInstance("@mozilla.org/hash-property-bag;1");
1392
1393   MOZ_TRY(propertyBag->SetPropertyAsBool(u"shuttingDown"_ns, mShuttingDown));
1394
1395   MOZ_TRY(propertyBag->SetPropertyAsBool(u"saveDataRunnableDispatched"_ns,
1396                                          mSaveDataRunnableDispatched));
1397
1398   propertyBag.forget(aBagOut);
1399
1400   return NS_OK;
1401 }
1402
1403 #define RELEASE_ASSERT_SUCCEEDED(rv, name)                                    \
1404   do {                                                                        \
1405     if (NS_FAILED(rv)) {                                                      \
1406       if ((rv) == NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS) {               \
1407         if (auto* context = CycleCollectedJSContext::Get()) {                 \
1408           if (RefPtr<Exception> exn = context->GetPendingException()) {       \
1409             MOZ_CRASH_UNSAFE_PRINTF("Failed to get " name ": %s",             \
1410                                     exn->GetMessageMoz().get());              \
1411           }                                                                   \
1412         }                                                                     \
1413       }                                                                       \
1414                                                                               \
1415       nsAutoCString errorName;                                                \
1416       GetErrorName(rv, errorName);                                            \
1417       MOZ_CRASH_UNSAFE_PRINTF("Failed to get " name ": %s", errorName.get()); \
1418     }                                                                         \
1419   } while (0)
1420
1421 nsCOMPtr<nsIAsyncShutdownClient> ServiceWorkerRegistrar::GetShutdownPhase()
1422     const {
1423   nsresult rv;
1424   nsCOMPtr<nsIAsyncShutdownService> svc =
1425       do_GetService("@mozilla.org/async-shutdown-service;1", &rv);
1426   // If this fails, something is very wrong on the JS side (or we're out of
1427   // memory), and there's no point in continuing startup. Include as much
1428   // information as possible in the crash report.
1429   RELEASE_ASSERT_SUCCEEDED(rv, "async shutdown service");
1430
1431   nsCOMPtr<nsIAsyncShutdownClient> client;
1432   rv = svc->GetProfileBeforeChange(getter_AddRefs(client));
1433   RELEASE_ASSERT_SUCCEEDED(rv, "profileBeforeChange shutdown blocker");
1434   return client;
1435 }
1436
1437 #undef RELEASE_ASSERT_SUCCEEDED
1438
1439 void ServiceWorkerRegistrar::Shutdown() {
1440   AssertIsOnBackgroundThread();
1441   MOZ_ASSERT(!mShuttingDown);
1442
1443   mShuttingDown = true;
1444   MaybeScheduleShutdownCompleted();
1445 }
1446
1447 NS_IMETHODIMP
1448 ServiceWorkerRegistrar::Observe(nsISupports* aSubject, const char* aTopic,
1449                                 const char16_t* aData) {
1450   MOZ_ASSERT(NS_IsMainThread());
1451
1452   if (!strcmp(aTopic, "profile-after-change")) {
1453     nsCOMPtr<nsIObserverService> observerService =
1454         services::GetObserverService();
1455     observerService->RemoveObserver(this, "profile-after-change");
1456
1457     // The profile is fully loaded, now we can proceed with the loading of data
1458     // from disk.
1459     ProfileStarted();
1460
1461     return NS_OK;
1462   }
1463
1464   MOZ_ASSERT(false, "ServiceWorkerRegistrar got unexpected topic!");
1465   return NS_ERROR_UNEXPECTED;
1466 }
1467
1468 }  // namespace mozilla::dom