/* -*- 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 "gfxFeature.h"
#include "mozilla/Preferences.h"
#include "mozilla/Sprintf.h"
#include "nsString.h"
namespace mozilla {
namespace gfx {
bool FeatureState::IsEnabled()
const {
return IsInitialized() && IsFeatureStatusSuccess(GetValue());
}
FeatureStatus FeatureState::GetValue()
const {
if (!IsInitialized()) {
return FeatureStatus::Unused;
}
if (mRuntime.mStatus != FeatureStatus::Unused) {
return mRuntime.mStatus;
}
if (mUser.mStatus == FeatureStatus::ForceEnabled) {
return FeatureStatus::ForceEnabled;
}
if (mEnvironment.mStatus != FeatureStatus::Unused) {
return mEnvironment.mStatus;
}
if (mUser.mStatus != FeatureStatus::Unused) {
return mUser.mStatus;
}
return mDefault.mStatus;
}
bool FeatureState::SetDefault(
bool aEnable, FeatureStatus aDisableStatus,
const char* aDisableMessage) {
if (!aEnable) {
DisableByDefault(aDisableStatus, aDisableMessage,
"FEATURE_FAILURE_DISABLED"_ns);
return false;
}
EnableByDefault();
return true;
}
void FeatureState::SetDefaultFromPref(
const char* aPrefName,
bool aIsEnablePref,
bool aDefaultValue,
Maybe<
bool> aUserValue) {
bool baseValue =
Preferences::GetBool(aPrefName, aDefaultValue, PrefValueKind::
Default);
SetDefault(baseValue == aIsEnablePref, FeatureStatus::Disabled,
"Disabled by default");
if (aUserValue) {
if (*aUserValue == aIsEnablePref) {
nsCString message(
"Enabled via ");
message.AppendASCII(aPrefName);
UserEnable(message.get());
}
else {
nsCString message(
"Disabled via ");
message.AppendASCII(aPrefName);
UserDisable(message.get(),
"FEATURE_FAILURE_PREF_OFF"_ns);
}
}
}
void FeatureState::SetDefaultFromPref(
const char* aPrefName,
bool aIsEnablePref,
bool aDefaultValue) {
Maybe<
bool> userValue;
if (Preferences::HasUserValue(aPrefName)) {
userValue.emplace(Preferences::GetBool(aPrefName, aDefaultValue));
}
SetDefaultFromPref(aPrefName, aIsEnablePref, aDefaultValue, userValue);
}
bool FeatureState::InitOrUpdate(
bool aEnable, FeatureStatus aDisableStatus,
const char* aDisableMessage) {
if (!IsInitialized()) {
return SetDefault(aEnable, aDisableStatus, aDisableMessage);
}
return MaybeSetFailed(aEnable, aDisableStatus, aDisableMessage, nsCString());
}
void FeatureState::UserEnable(
const char* aMessage) {
AssertInitialized();
SetUser(FeatureStatus::Available, aMessage, nsCString());
}
void FeatureState::UserForceEnable(
const char* aMessage) {
AssertInitialized();
SetUser(FeatureStatus::ForceEnabled, aMessage, nsCString());
}
void FeatureState::UserDisable(
const char* aMessage,
const nsACString& aFailureId) {
AssertInitialized();
SetUser(FeatureStatus::Disabled, aMessage, aFailureId);
}
void FeatureState::Disable(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
AssertInitialized();
// We should never bother setting an environment status to "enabled," since
// it could override an explicit user decision to disable it.
MOZ_ASSERT(IsFeatureStatusFailure(aStatus));
SetEnvironment(aStatus, aMessage, aFailureId);
}
void FeatureState::SetFailed(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
AssertInitialized();
// We should never bother setting a runtime status to "enabled," since it
// could override an explicit user decision to disable it.
MOZ_ASSERT(IsFeatureStatusFailure(aStatus));
SetRuntime(aStatus, aMessage, aFailureId);
}
bool FeatureState::MaybeSetFailed(
bool aEnable, FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
if (!aEnable) {
SetFailed(aStatus, aMessage, aFailureId);
return false;
}
return true;
}
bool FeatureState::MaybeSetFailed(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
return MaybeSetFailed(IsFeatureStatusSuccess(aStatus), aStatus, aMessage,
aFailureId);
}
bool FeatureState::DisabledByDefault()
const {
return mDefault.mStatus != FeatureStatus::Available;
}
bool FeatureState::IsForcedOnByUser()
const {
AssertInitialized();
return mUser.mStatus == FeatureStatus::ForceEnabled;
}
void FeatureState::EnableByDefault() {
// User/runtime decisions should not have been made yet.
MOZ_ASSERT(!mUser.IsInitialized());
MOZ_ASSERT(!mEnvironment.IsInitialized());
MOZ_ASSERT(!mRuntime.IsInitialized());
mDefault.Set(FeatureStatus::Available);
}
void FeatureState::DisableByDefault(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
// User/runtime decisions should not have been made yet.
MOZ_ASSERT(!mUser.IsInitialized());
MOZ_ASSERT(!mEnvironment.IsInitialized());
MOZ_ASSERT(!mRuntime.IsInitialized());
// Make sure that when disabling we actually use a failure status.
MOZ_ASSERT(IsFeatureStatusFailure(aStatus));
mDefault.Set(aStatus, aMessage, aFailureId);
}
void FeatureState::SetUser(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
// Default decision must have been made, but not runtime or environment.
MOZ_ASSERT(mDefault.IsInitialized());
MOZ_ASSERT(!mEnvironment.IsInitialized());
MOZ_ASSERT(!mRuntime.IsInitialized());
mUser.Set(aStatus, aMessage, aFailureId);
}
void FeatureState::SetEnvironment(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
// Default decision must have been made, but not runtime.
MOZ_ASSERT(mDefault.IsInitialized());
MOZ_ASSERT(!mRuntime.IsInitialized());
mEnvironment.Set(aStatus, aMessage, aFailureId);
}
void FeatureState::SetRuntime(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
AssertInitialized();
mRuntime.Set(aStatus, aMessage, aFailureId);
}
const char* FeatureState::GetRuntimeMessage()
const {
MOZ_ASSERT(IsFeatureStatusFailure(mRuntime.mStatus));
return mRuntime.mMessage;
}
void FeatureState::ForEachStatusChange(
const StatusIterCallback& aCallback)
const {
AssertInitialized();
aCallback(
"default", mDefault.mStatus, mDefault.MessageOrNull(),
mDefault.FailureId());
if (mUser.IsInitialized()) {
aCallback(
"user", mUser.mStatus, mUser.Message(), mUser.FailureId());
}
if (mEnvironment.IsInitialized()) {
aCallback(
"env", mEnvironment.mStatus, mEnvironment.Message(),
mEnvironment.FailureId());
}
if (mRuntime.IsInitialized()) {
aCallback(
"runtime", mRuntime.mStatus, mRuntime.Message(),
mRuntime.FailureId());
}
}
const char* FeatureState::GetFailureMessage()
const {
AssertInitialized();
MOZ_ASSERT(!IsEnabled());
if (mRuntime.mStatus != FeatureStatus::Unused &&
IsFeatureStatusFailure(mRuntime.mStatus)) {
return mRuntime.mMessage;
}
if (mEnvironment.mStatus != FeatureStatus::Unused &&
IsFeatureStatusFailure(mEnvironment.mStatus)) {
return mEnvironment.mMessage;
}
if (mUser.mStatus != FeatureStatus::Unused &&
IsFeatureStatusFailure(mUser.mStatus)) {
return mUser.mMessage;
}
MOZ_ASSERT(IsFeatureStatusFailure(mDefault.mStatus));
return mDefault.mMessage;
}
const nsCString& FeatureState::GetFailureId()
const {
MOZ_ASSERT(!IsEnabled());
if (mRuntime.mStatus != FeatureStatus::Unused) {
return mRuntime.mFailureId;
}
if (mEnvironment.mStatus != FeatureStatus::Unused) {
return mEnvironment.mFailureId;
}
if (mUser.mStatus != FeatureStatus::Unused) {
return mUser.mFailureId;
}
return mDefault.mFailureId;
}
nsCString FeatureState::GetStatusAndFailureIdString()
const {
nsCString status;
auto value = GetValue();
switch (value) {
case FeatureStatus::Blocklisted:
case FeatureStatus::Disabled:
case FeatureStatus::Unavailable:
case FeatureStatus::UnavailableNoAngle:
case FeatureStatus::Blocked:
status.AppendPrintf(
"%s:%s", FeatureStatusToString(value),
GetFailureId().get());
break;
case FeatureStatus::Failed:
status.AppendPrintf(
"%s:%s", FeatureStatusToString(value),
GetFailureMessage());
break;
default:
status.Append(FeatureStatusToString(value));
break;
}
return status;
}
void FeatureState::Reset() {
mDefault.Set(FeatureStatus::Unused);
mUser.Set(FeatureStatus::Unused);
mEnvironment.Set(FeatureStatus::Unused);
mRuntime.Set(FeatureStatus::Unused);
}
void FeatureState::Instance::Set(FeatureStatus aStatus) {
mStatus = aStatus;
mMessage[0] =
'\0';
mFailureId.Truncate();
}
void FeatureState::Instance::Set(FeatureStatus aStatus,
const char* aMessage,
const nsACString& aFailureId) {
mStatus = aStatus;
if (aMessage) {
SprintfLiteral(mMessage,
"%s", aMessage);
}
else {
mMessage[0] =
'\0';
}
mFailureId.Assign(aFailureId);
}
}
// namespace gfx
}
// namespace mozilla
