Bug 1592934 - Abstract first initialization attempt recording into a standalone class; r=ttung,dom-workers-and-storage-reviewers,sg

Differential Revision: https://phabricator.services.mozilla.com/D55653

--HG--
extra : moz-landing-system : lando

dom/quota/ActorsParent.cpp

@@ -192,9 +192,6 @@ const char kAboutHomeOriginPrefix[] = "moz-safe-about:home";
 const char kIndexedDBOriginPrefix[] = "indexeddb://";
 const char kResourceOriginPrefix[] = "resource://";
 
-constexpr auto kStorageTelemetryKey = NS_LITERAL_CSTRING("Storage");
-constexpr auto kTempStorageTelemetryKey =
-    NS_LITERAL_CSTRING("TemporaryStorage");
 constexpr auto kPersistentOriginTelemetryKey =
     NS_LITERAL_CSTRING("PersistentOrigin");
 constexpr auto kTemporaryOriginTelemetryKey =
@@ -3494,8 +3491,6 @@ QuotaManager::QuotaManager()
       mTemporaryStorageLimit(0),
       mTemporaryStorageUsage(0),
       mNextDirectoryLockId(0),
-      mStorageInitializationAttempted(false),
-      mTemporaryStorageInitializationAttempted(false),
       mTemporaryStorageInitialized(false),
       mCacheUsable(false) {
   AssertIsOnOwningThread();
@@ -6318,21 +6313,13 @@ nsresult QuotaManager::EnsureStorageIsInitialized() {
   AssertIsOnIOThread();
 
   if (mStorageConnection) {
-    MOZ_ASSERT(mStorageInitializationAttempted);
+    mInitializationInfo.AssertInitializationAttempted(Initialization::Storage);
     return NS_OK;
   }
 
-  auto autoReportTelemetry = MakeScopeExit([&]() {
-    Telemetry::Accumulate(Telemetry::QM_FIRST_INITIALIZATION_ATTEMPT,
-                          kStorageTelemetryKey,
-                          static_cast<uint32_t>(!!mStorageConnection));
-  });
-
-  if (mStorageInitializationAttempted) {
-    autoReportTelemetry.release();
-  }
-
-  mStorageInitializationAttempted = true;
+  const auto autoRecord = mInitializationInfo.RecordFirstInitializationAttempt(
+      Initialization::Storage,
+      [& self = *this]() { return !!self.mStorageConnection; });
 
   nsCOMPtr<nsIFile> storageFile;
   nsresult rv = NS_NewLocalFile(mBasePath, false, getter_AddRefs(storageFile));
@@ -6979,21 +6966,14 @@ nsresult QuotaManager::EnsureTemporaryStorageIsInitialized() {
   MOZ_ASSERT(mStorageConnection);
 
   if (mTemporaryStorageInitialized) {
-    MOZ_ASSERT(mTemporaryStorageInitializationAttempted);
+    mInitializationInfo.AssertInitializationAttempted(
+        Initialization::TemporaryStorage);
     return NS_OK;
   }
 
-  auto autoReportTelemetry = MakeScopeExit([&]() {
-    Telemetry::Accumulate(Telemetry::QM_FIRST_INITIALIZATION_ATTEMPT,
-                          kTempStorageTelemetryKey,
-                          static_cast<uint32_t>(mTemporaryStorageInitialized));
-  });
-
-  if (mTemporaryStorageInitializationAttempted) {
-    autoReportTelemetry.release();
-  }
-
-  mTemporaryStorageInitializationAttempted = true;
+  const auto autoRecord = mInitializationInfo.RecordFirstInitializationAttempt(
+      Initialization::TemporaryStorage,
+      [& self = *this]() { return self.mTemporaryStorageInitialized; });
 
   nsresult rv;
 
@@ -7062,13 +7042,12 @@ void QuotaManager::ShutdownStorage() {
       mTemporaryStorageInitialized = false;
     }
 
-    mTemporaryStorageInitializationAttempted = false;
-
     ReleaseIOThreadObjects();
 
     mStorageConnection = nullptr;
-    mStorageInitializationAttempted = false;
   }
+
+  mInitializationInfo.ResetInitializationAttempts();
 }
 
 nsresult QuotaManager::EnsureOriginDirectory(nsIFile* aDirectory,

dom/quota/InitializationTypes.h

@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_quota_InitializationTypes_h
+#define mozilla_dom_quota_InitializationTypes_h
+
+#include "mozilla/Telemetry.h"
+#include "mozilla/TypedEnumBits.h"
+
+namespace mozilla {
+namespace dom {
+namespace quota {
+
+enum class Initialization {
+  None = 0,
+  Storage = 1 << 0,
+  TemporaryStorage = 1 << 1,
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Initialization)
+
+class InitializationInfo final {
+  Initialization mInitializationAttempts = Initialization::None;
+
+ public:
+  template <typename SuccessFunction>
+  class AutoInitializationAttempt {
+    InitializationInfo& mOwner;
+    const Initialization mInitialization;
+    const SuccessFunction mSuccessFunction;
+
+   public:
+    AutoInitializationAttempt(InitializationInfo& aOwner,
+                              const Initialization aInitialization,
+                              const SuccessFunction&& aSuccessFunction)
+        : mOwner(aOwner),
+          mInitialization(aInitialization),
+          mSuccessFunction(aSuccessFunction) {}
+
+    ~AutoInitializationAttempt() {
+      if (!(mOwner.mInitializationAttempts & mInitialization)) {
+        mOwner.mInitializationAttempts |= mInitialization;
+        Telemetry::Accumulate(Telemetry::QM_FIRST_INITIALIZATION_ATTEMPT,
+                              mOwner.GetInitializationString(mInitialization),
+                              static_cast<uint32_t>(mSuccessFunction()));
+      }
+    }
+  };
+
+  template <typename SuccessFunction>
+  AutoInitializationAttempt<SuccessFunction> RecordFirstInitializationAttempt(
+      const Initialization aInitialization,
+      SuccessFunction&& aSuccessFunction) {
+    return AutoInitializationAttempt<SuccessFunction>(
+        *this, aInitialization, std::move(aSuccessFunction));
+  }
+
+  void AssertInitializationAttempted(Initialization aInitialization) {
+    MOZ_ASSERT(mInitializationAttempts & aInitialization);
+  }
+
+  void ResetInitializationAttempts() {
+    mInitializationAttempts = Initialization::None;
+  }
+
+ private:
+  // TODO: Use constexpr here once bug 1594094 is addressed.
+  nsLiteralCString GetInitializationString(Initialization aInitialization) {
+    switch (aInitialization) {
+      case Initialization::Storage:
+        return NS_LITERAL_CSTRING("Storage");
+      case Initialization::TemporaryStorage:
+        return NS_LITERAL_CSTRING("TemporaryStorage");
+
+      default:
+        MOZ_CRASH("Bad initialization value!");
+    }
+  }
+};
+
+}  // namespace quota
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_quota_InitializationTypes_h

dom/quota/QuotaManager.h

@@ -16,6 +16,7 @@
 #include "nsClassHashtable.h"
 #include "nsRefPtrHashtable.h"
 
+#include "InitializationTypes.h"
 #include "Client.h"
 #include "PersistenceType.h"
 
@@ -632,6 +633,8 @@ class QuotaManager final : public BackgroundThreadObject {
   AutoTArray<Client::Type, Client::TYPE_MAX> mAllClientTypes;
   AutoTArray<Client::Type, Client::TYPE_MAX> mAllClientTypesExceptLS;
 
+  InitializationInfo mInitializationInfo;
+
   nsString mBasePath;
   nsString mIndexedDBPath;
   nsString mStoragePath;
@@ -642,8 +645,6 @@ class QuotaManager final : public BackgroundThreadObject {
   uint64_t mTemporaryStorageLimit;
   uint64_t mTemporaryStorageUsage;
   int64_t mNextDirectoryLockId;
-  bool mStorageInitializationAttempted;
-  bool mTemporaryStorageInitializationAttempted;
   bool mTemporaryStorageInitialized;
   bool mCacheUsable;
 };

dom/quota/moz.build

@@ -39,6 +39,7 @@ EXPORTS.mozilla.dom.quota += [
     'CheckedUnsafePtr.h',
     'Client.h',
     'FileStreams.h',
+    'InitializationTypes.h',
     'MemoryOutputStream.h',
     'OriginScope.h',
     'PersistenceType.h',