1 files changed, 220 insertions, 0 deletions
diff --git a/dom/indexedDB/PermissionRequestBase.cpp b/dom/indexedDB/PermissionRequestBase.cpp
new file mode 100644
index 0000000000..373232b11a
--- /dev/null
+++ b/dom/indexedDB/PermissionRequestBase.cpp
@@ -0,0 +1,220 @@
+/* -*- 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/. */
+
+#include "PermissionRequestBase.h"
+
+#include "IndexedDBCommon.h"
+
+#include "MainThreadUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Services.h"
+#include "mozilla/dom/Element.h"
+#include "nsIObserverService.h"
+#include "nsIPrincipal.h"
+#include "nsXULAppAPI.h"
+
+namespace mozilla::dom::indexedDB {
+
+using namespace mozilla::services;
+
+namespace {
+
+#define IDB_PREFIX "indexedDB"
+#define TOPIC_PREFIX IDB_PREFIX "-permissions-"
+
+const nsLiteralCString kPermissionString = nsLiteralCString(IDB_PREFIX);
+
+const char kPermissionPromptTopic[] = TOPIC_PREFIX "prompt";
+
+#ifdef DEBUG
+const char kPermissionResponseTopic[] = TOPIC_PREFIX "response";
+#endif
+
+#undef TOPIC_PREFIX
+#undef IDB_PREFIX
+
+const uint32_t kPermissionDefault = nsIPermissionManager::UNKNOWN_ACTION;
+
+void AssertSanity() {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+}
+
+}  // namespace
+
+PermissionRequestBase::PermissionRequestBase(Element* aOwnerElement,
+                                             nsIPrincipal* aPrincipal)
+    : mOwnerElement(aOwnerElement), mPrincipal(aPrincipal) {
+  AssertSanity();
+  MOZ_ASSERT(aOwnerElement);
+  MOZ_ASSERT(aPrincipal);
+}
+
+PermissionRequestBase::~PermissionRequestBase() { AssertSanity(); }
+
+// static
+Result<PermissionRequestBase::PermissionValue, nsresult>
+PermissionRequestBase::GetCurrentPermission(nsIPrincipal& aPrincipal) {
+  AssertSanity();
+
+  const nsCOMPtr<nsIPermissionManager> permMan = GetPermissionManager();
+  IDB_TRY(OkIf(permMan), Err(NS_ERROR_FAILURE));
+
+  IDB_TRY_INSPECT(
+      const uint32_t& intPermission,
+      MOZ_TO_RESULT_INVOKE(permMan, TestExactPermissionFromPrincipal,
+                           &aPrincipal, kPermissionString));
+
+  const PermissionValue permission =
+      PermissionValueForIntPermission(intPermission);
+
+  MOZ_ASSERT(permission == kPermissionAllowed ||
+             permission == kPermissionDenied ||
+             permission == kPermissionPrompt);
+
+  return permission;
+}
+
+// static
+auto PermissionRequestBase::PermissionValueForIntPermission(
+    uint32_t aIntPermission) -> PermissionValue {
+  AssertSanity();
+
+  switch (aIntPermission) {
+    case kPermissionDefault:
+      return kPermissionPrompt;
+    case kPermissionAllowed:
+      return kPermissionAllowed;
+    case kPermissionDenied:
+      return kPermissionDenied;
+    default:
+      MOZ_CRASH("Bad permission!");
+  }
+
+  MOZ_CRASH("Should never get here!");
+}
+
+Result<PermissionRequestBase::PermissionValue, nsresult>
+PermissionRequestBase::PromptIfNeeded() {
+  AssertSanity();
+  MOZ_ASSERT(mPrincipal);
+
+  // Tricky, we want to release the window and principal in all cases except
+  // when we successfully prompt.
+  nsCOMPtr<Element> element = std::move(mOwnerElement);
+  nsCOMPtr<nsIPrincipal> principal = std::move(mPrincipal);
+
+  IDB_TRY_INSPECT(const PermissionValue& currentValue,
+                  GetCurrentPermission(*principal));
+  MOZ_ASSERT(currentValue != kPermissionDefault);
+
+  if (currentValue == kPermissionPrompt) {
+    nsCOMPtr<nsIObserverService> obsSvc = GetObserverService();
+    IDB_TRY(OkIf(obsSvc), Err(NS_ERROR_FAILURE));
+
+    // We're about to prompt so move the members back.
+    mOwnerElement = std::move(element);
+    mPrincipal = std::move(principal);
+
+    IDB_TRY(obsSvc->NotifyObservers(static_cast<nsIObserver*>(this),
+                                    kPermissionPromptTopic, nullptr),
+            QM_PROPAGATE, [this](const auto&) {
+              // Finally release if we failed the prompt.
+              mOwnerElement = nullptr;
+              mPrincipal = nullptr;
+            });
+  }
+
+  return currentValue;
+}
+
+void PermissionRequestBase::SetExplicitPermission(nsIPrincipal* aPrincipal,
+                                                  uint32_t aIntPermission) {
+  AssertSanity();
+  MOZ_ASSERT(aPrincipal);
+  MOZ_ASSERT(aIntPermission == kPermissionAllowed ||
+             aIntPermission == kPermissionDenied);
+
+  nsCOMPtr<nsIPermissionManager> permMan = GetPermissionManager();
+  if (NS_WARN_IF(!permMan)) {
+    return;
+  }
+
+  nsresult rv =
+      permMan->AddFromPrincipal(aPrincipal, kPermissionString, aIntPermission,
+                                nsIPermissionManager::EXPIRE_NEVER,
+                                /* aExpireTime */ 0);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return;
+  }
+}
+
+NS_IMPL_ISUPPORTS(PermissionRequestBase, nsIObserver, nsIIDBPermissionsRequest)
+
+NS_IMETHODIMP
+PermissionRequestBase::GetBrowserElement(Element** aElement) {
+  AssertSanity();
+  *aElement = do_AddRef(mOwnerElement).take();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PermissionRequestBase::GetResponseObserver(nsIObserver** aObserver) {
+  AssertSanity();
+  *aObserver = do_AddRef(this).take();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PermissionRequestBase::Observe(nsISupports* aSubject, const char* aTopic,
+                               const char16_t* aData) {
+  AssertSanity();
+  MOZ_ASSERT(!strcmp(aTopic, kPermissionResponseTopic));
+  MOZ_ASSERT(mOwnerElement);
+  MOZ_ASSERT(mPrincipal);
+
+  const nsCOMPtr<Element> element = std::move(mOwnerElement);
+  Unused << element;
+  const nsCOMPtr<nsIPrincipal> principal = std::move(mPrincipal);
+
+  nsresult rv;
+  uint32_t promptResult = nsDependentString(aData).ToInteger(&rv);
+  MOZ_ALWAYS_SUCCEEDS(rv);
+
+  // The UI prompt code will only return one of these three values. We have to
+  // transform it to our values.
+  MOZ_ASSERT(promptResult == kPermissionDefault ||
+             promptResult == kPermissionAllowed ||
+             promptResult == kPermissionDenied);
+
+  if (promptResult != kPermissionDefault) {
+    // Save explicitly allowed or denied permissions now.
+    SetExplicitPermission(principal, promptResult);
+  }
+
+  PermissionValue permission;
+  switch (promptResult) {
+    case kPermissionDefault:
+      permission = kPermissionPrompt;
+      break;
+
+    case kPermissionAllowed:
+      permission = kPermissionAllowed;
+      break;
+
+    case kPermissionDenied:
+      permission = kPermissionDenied;
+      break;
+
+    default:
+      MOZ_CRASH("Bad prompt result!");
+  }
+
+  OnPromptComplete(permission);
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom::indexedDB