summaryrefslogtreecommitdiffstats
path: root/gfx/config/gfxFeature.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /gfx/config/gfxFeature.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'gfx/config/gfxFeature.cpp')
-rw-r--r--gfx/config/gfxFeature.cpp313
1 files changed, 313 insertions, 0 deletions
diff --git a/gfx/config/gfxFeature.cpp b/gfx/config/gfxFeature.cpp
new file mode 100644
index 000000000..53e291ffe
--- /dev/null
+++ b/gfx/config/gfxFeature.cpp
@@ -0,0 +1,313 @@
+/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set sts=2 ts=8 sw=2 tw=99 et: */
+/* 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,
+ NS_LITERAL_CSTRING("FEATURE_FAILURE_DISABLED"));
+ return false;
+ }
+ EnableByDefault();
+ return true;
+}
+
+void
+FeatureState::SetDefaultFromPref(const char* aPrefName,
+ bool aIsEnablePref,
+ bool aDefaultValue)
+{
+ bool baseValue = Preferences::GetDefaultBool(aPrefName, aDefaultValue);
+ SetDefault(baseValue == aIsEnablePref, FeatureStatus::Disabled, "Disabled by default");
+
+ if (Preferences::HasUserValue(aPrefName)) {
+ bool userValue = Preferences::GetBool(aPrefName, aDefaultValue);
+ if (userValue == aIsEnablePref) {
+ nsCString message("Enabled via ");
+ message.AppendASCII(aPrefName);
+ UserEnable(message.get());
+ } else {
+ nsCString message("Disabled via ");
+ message.AppendASCII(aPrefName);
+ UserDisable(message.get(), NS_LITERAL_CSTRING("FEATURE_FAILURE_PREF_OFF"));
+ }
+ }
+}
+
+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);
+}
+
+void
+FeatureState::UserForceEnable(const char* aMessage)
+{
+ AssertInitialized();
+ SetUser(FeatureStatus::ForceEnabled, aMessage);
+}
+
+void
+FeatureState::UserDisable(const char* aMessage, const nsACString& aFailureId)
+{
+ AssertInitialized();
+ SetUser(FeatureStatus::Disabled, aMessage);
+ SetFailureId(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);
+ SetFailureId(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);
+ SetFailureId(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());
+
+ mDefault.Set(aStatus, aMessage);
+ SetFailureId(aFailureId);
+}
+
+void
+FeatureState::SetUser(FeatureStatus aStatus, const char* aMessage)
+{
+ // 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);
+}
+
+void
+FeatureState::SetEnvironment(FeatureStatus aStatus, const char* aMessage)
+{
+ // Default decision must have been made, but not runtime.
+ MOZ_ASSERT(mDefault.IsInitialized());
+ MOZ_ASSERT(!mRuntime.IsInitialized());
+
+ mEnvironment.Set(aStatus, aMessage);
+}
+
+void
+FeatureState::SetRuntime(FeatureStatus aStatus, const char* aMessage)
+{
+ AssertInitialized();
+
+ mRuntime.Set(aStatus, aMessage);
+}
+
+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());
+ if (mUser.IsInitialized()) {
+ aCallback("user", mUser.mStatus, mUser.Message());
+ }
+ if (mEnvironment.IsInitialized()) {
+ aCallback("env", mEnvironment.mStatus, mEnvironment.Message());
+ }
+ if (mRuntime.IsInitialized()) {
+ aCallback("runtime", mRuntime.mStatus, mRuntime.Message());
+ }
+}
+
+void
+FeatureState::SetFailureId(const nsACString& aFailureId)
+{
+ if (mFailureId.IsEmpty()) {
+ mFailureId = aFailureId;
+ }
+}
+
+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());
+ return mFailureId;
+}
+
+void
+FeatureState::Reset()
+{
+ mDefault.Set(FeatureStatus::Unused);
+ mUser.Set(FeatureStatus::Unused);
+ mEnvironment.Set(FeatureStatus::Unused);
+ mRuntime.Set(FeatureStatus::Unused);
+ mFailureId = nsCString();
+}
+
+void
+FeatureState::Instance::Set(FeatureStatus aStatus, const char* aMessage /* = nullptr */)
+{
+ mStatus = aStatus;
+ if (aMessage) {
+ SprintfLiteral(mMessage, "%s", aMessage);
+ } else {
+ mMessage[0] = '\0';
+ }
+}
+
+} // namespace gfx
+} // namespace mozilla