gecko-dev/dom/indexedDB/PermissionRequestBase.cpp

268 строки
6.8 KiB
C++

/* -*- 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 "MainThreadUtils.h"
#include "mozilla/Assertions.h"
#include "mozilla/Services.h"
#include "mozilla/dom/Element.h"
#include "nsIDOMWindow.h"
#include "nsIObserverService.h"
#include "nsIPrincipal.h"
#include "nsPIDOMWindow.h"
#include "nsXULAppAPI.h"
namespace mozilla {
namespace dom {
namespace indexedDB {
using namespace mozilla::services;
namespace {
#define IDB_PREFIX "indexedDB"
#define TOPIC_PREFIX IDB_PREFIX "-permissions-"
const char kPermissionString[] = 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
nsresult
PermissionRequestBase::GetCurrentPermission(nsIPrincipal* aPrincipal,
PermissionValue* aCurrentValue)
{
AssertSanity();
MOZ_ASSERT(aPrincipal);
MOZ_ASSERT(aCurrentValue);
nsCOMPtr<nsIPermissionManager> permMan = GetPermissionManager();
if (NS_WARN_IF(!permMan)) {
return NS_ERROR_FAILURE;
}
uint32_t intPermission;
nsresult rv = permMan->TestExactPermissionFromPrincipal(
aPrincipal,
kPermissionString,
&intPermission);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
PermissionValue permission =
PermissionValueForIntPermission(intPermission);
MOZ_ASSERT(permission == kPermissionAllowed ||
permission == kPermissionDenied ||
permission == kPermissionPrompt);
*aCurrentValue = permission;
return NS_OK;
}
// 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!");
}
nsresult
PermissionRequestBase::PromptIfNeeded(PermissionValue* aCurrentValue)
{
AssertSanity();
MOZ_ASSERT(aCurrentValue);
MOZ_ASSERT(mPrincipal);
// Tricky, we want to release the window and principal in all cases except
// when we successfully prompt.
nsCOMPtr<Element> element;
mOwnerElement.swap(element);
nsCOMPtr<nsIPrincipal> principal;
mPrincipal.swap(principal);
PermissionValue currentValue;
nsresult rv = GetCurrentPermission(principal, &currentValue);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
MOZ_ASSERT(currentValue != kPermissionDefault);
if (currentValue == kPermissionPrompt) {
nsCOMPtr<nsIObserverService> obsSvc = GetObserverService();
if (NS_WARN_IF(!obsSvc)) {
return NS_ERROR_FAILURE;
}
// We're about to prompt so swap the members back.
element.swap(mOwnerElement);
principal.swap(mPrincipal);
rv = obsSvc->NotifyObservers(static_cast<nsIObserver*>(this),
kPermissionPromptTopic,
nullptr);
if (NS_WARN_IF(NS_FAILED(rv))) {
// Finally release if we failed the prompt.
mOwnerElement = nullptr;
mPrincipal = nullptr;
return rv;
}
}
*aCurrentValue = currentValue;
return NS_OK;
}
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);
nsCOMPtr<Element> element;
element.swap(mOwnerElement);
nsCOMPtr<nsIPrincipal> principal;
mPrincipal.swap(principal);
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 indexedDB
} // namespace dom
} // namespace mozilla