diff options
Diffstat (limited to 'widget/GfxInfoBase.cpp')
| -rw-r--r-- | widget/GfxInfoBase.cpp | 1438 |
1 files changed, 1438 insertions, 0 deletions
diff --git a/widget/GfxInfoBase.cpp b/widget/GfxInfoBase.cpp new file mode 100644 index 000000000..e53db69c5 --- /dev/null +++ b/widget/GfxInfoBase.cpp @@ -0,0 +1,1438 @@ +/* vim: se cin sw=2 ts=2 et : */ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "mozilla/ArrayUtils.h" + +#include "GfxInfoBase.h" + +#include "GfxInfoWebGL.h" +#include "GfxDriverInfo.h" +#include "nsCOMPtr.h" +#include "nsCOMArray.h" +#include "nsString.h" +#include "nsUnicharUtils.h" +#include "nsVersionComparator.h" +#include "mozilla/Services.h" +#include "mozilla/Observer.h" +#include "nsIObserver.h" +#include "nsIObserverService.h" +#include "nsIDOMElement.h" +#include "nsIDOMHTMLCollection.h" +#include "nsIDOMNode.h" +#include "nsIDOMNodeList.h" +#include "nsTArray.h" +#include "nsXULAppAPI.h" +#include "nsIXULAppInfo.h" +#include "mozilla/Preferences.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Logging.h" +#include "MediaPrefs.h" +#include "gfxPrefs.h" +#include "gfxPlatform.h" +#include "gfxConfig.h" +#include "DriverCrashGuard.h" + +#if defined(MOZ_CRASHREPORTER) +#include "nsExceptionHandler.h" +#endif + +using namespace mozilla::widget; +using namespace mozilla; +using mozilla::MutexAutoLock; + +nsTArray<GfxDriverInfo>* GfxInfoBase::mDriverInfo; +bool GfxInfoBase::mDriverInfoObserverInitialized; + +// Observes for shutdown so that the child GfxDriverInfo list is freed. +class ShutdownObserver : public nsIObserver +{ + virtual ~ShutdownObserver() {} + +public: + ShutdownObserver() {} + + NS_DECL_ISUPPORTS + + NS_IMETHOD Observe(nsISupports *subject, const char *aTopic, + const char16_t *aData) override + { + MOZ_ASSERT(strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0); + + delete GfxInfoBase::mDriverInfo; + GfxInfoBase::mDriverInfo = nullptr; + + for (uint32_t i = 0; i < DeviceFamilyMax; i++) + delete GfxDriverInfo::mDeviceFamilies[i]; + + for (uint32_t i = 0; i < DeviceVendorMax; i++) + delete GfxDriverInfo::mDeviceVendors[i]; + + return NS_OK; + } +}; + +NS_IMPL_ISUPPORTS(ShutdownObserver, nsIObserver) + +void InitGfxDriverInfoShutdownObserver() +{ + if (GfxInfoBase::mDriverInfoObserverInitialized) + return; + + GfxInfoBase::mDriverInfoObserverInitialized = true; + + nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); + if (!observerService) { + NS_WARNING("Could not get observer service!"); + return; + } + + ShutdownObserver *obs = new ShutdownObserver(); + observerService->AddObserver(obs, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); +} + +using namespace mozilla::widget; +using namespace mozilla::gfx; +using namespace mozilla; + +NS_IMPL_ISUPPORTS(GfxInfoBase, nsIGfxInfo, nsIObserver, nsISupportsWeakReference) + +#define BLACKLIST_PREF_BRANCH "gfx.blacklist." +#define SUGGESTED_VERSION_PREF BLACKLIST_PREF_BRANCH "suggested-driver-version" +#define BLACKLIST_ENTRY_TAG_NAME "gfxBlacklistEntry" + +static const char* +GetPrefNameForFeature(int32_t aFeature) +{ + const char* name = nullptr; + switch(aFeature) { + case nsIGfxInfo::FEATURE_DIRECT2D: + name = BLACKLIST_PREF_BRANCH "direct2d"; + break; + case nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS: + name = BLACKLIST_PREF_BRANCH "layers.direct3d9"; + break; + case nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS: + name = BLACKLIST_PREF_BRANCH "layers.direct3d10"; + break; + case nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS: + name = BLACKLIST_PREF_BRANCH "layers.direct3d10-1"; + break; + case nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS: + name = BLACKLIST_PREF_BRANCH "layers.direct3d11"; + break; + case nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE: + name = BLACKLIST_PREF_BRANCH "direct3d11angle"; + break; + case nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING: + name = BLACKLIST_PREF_BRANCH "hardwarevideodecoding"; + break; + case nsIGfxInfo::FEATURE_OPENGL_LAYERS: + name = BLACKLIST_PREF_BRANCH "layers.opengl"; + break; + case nsIGfxInfo::FEATURE_WEBGL_OPENGL: + name = BLACKLIST_PREF_BRANCH "webgl.opengl"; + break; + case nsIGfxInfo::FEATURE_WEBGL_ANGLE: + name = BLACKLIST_PREF_BRANCH "webgl.angle"; + break; + case nsIGfxInfo::FEATURE_WEBGL_MSAA: + name = BLACKLIST_PREF_BRANCH "webgl.msaa"; + break; + case nsIGfxInfo::FEATURE_STAGEFRIGHT: + name = BLACKLIST_PREF_BRANCH "stagefright"; + break; + case nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION: + name = BLACKLIST_PREF_BRANCH "webrtc.hw.acceleration"; + break; + case nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE: + name = BLACKLIST_PREF_BRANCH "webrtc.hw.acceleration.encode"; + break; + case nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE: + name = BLACKLIST_PREF_BRANCH "webrtc.hw.acceleration.decode"; + break; + case nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION: + name = BLACKLIST_PREF_BRANCH "canvas2d.acceleration"; + break; + case nsIGfxInfo::FEATURE_VP8_HW_DECODE: + case nsIGfxInfo::FEATURE_VP9_HW_DECODE: + case nsIGfxInfo::FEATURE_DX_INTEROP2: + // We don't provide prefs for these features. + break; + default: + MOZ_ASSERT_UNREACHABLE("Unexpected nsIGfxInfo feature?!"); + break; + } + + return name; +} + +// Returns the value of the pref for the relevant feature in aValue. +// If the pref doesn't exist, aValue is not touched, and returns false. +static bool +GetPrefValueForFeature(int32_t aFeature, int32_t& aValue, nsACString& aFailureId) +{ + const char *prefname = GetPrefNameForFeature(aFeature); + if (!prefname) + return false; + + aValue = nsIGfxInfo::FEATURE_STATUS_UNKNOWN; + if (!NS_SUCCEEDED(Preferences::GetInt(prefname, &aValue))) { + return false; + } + + nsCString failureprefname(prefname); + failureprefname += ".failureid"; + nsAdoptingCString failureValue = Preferences::GetCString(failureprefname.get()); + if (failureValue) { + aFailureId = failureValue.get(); + } else { + aFailureId = "FEATURE_FAILURE_BLACKLIST_PREF"; + } + + return true; +} + +static void +SetPrefValueForFeature(int32_t aFeature, int32_t aValue, const nsACString& aFailureId) +{ + const char *prefname = GetPrefNameForFeature(aFeature); + if (!prefname) + return; + + Preferences::SetInt(prefname, aValue); + if (!aFailureId.IsEmpty()) { + nsCString failureprefname(prefname); + failureprefname += ".failureid"; + Preferences::SetCString(failureprefname.get(), aFailureId); + } +} + +static void +RemovePrefForFeature(int32_t aFeature) +{ + const char *prefname = GetPrefNameForFeature(aFeature); + if (!prefname) + return; + + Preferences::ClearUser(prefname); +} + +static bool +GetPrefValueForDriverVersion(nsCString& aVersion) +{ + return NS_SUCCEEDED(Preferences::GetCString(SUGGESTED_VERSION_PREF, + &aVersion)); +} + +static void +SetPrefValueForDriverVersion(const nsAString& aVersion) +{ + Preferences::SetString(SUGGESTED_VERSION_PREF, aVersion); +} + +static void +RemovePrefForDriverVersion() +{ + Preferences::ClearUser(SUGGESTED_VERSION_PREF); +} + + +static OperatingSystem +BlacklistOSToOperatingSystem(const nsAString& os) +{ + if (os.EqualsLiteral("WINNT 5.1")) + return OperatingSystem::WindowsXP; + else if (os.EqualsLiteral("WINNT 5.2")) + return OperatingSystem::WindowsServer2003; + else if (os.EqualsLiteral("WINNT 6.0")) + return OperatingSystem::WindowsVista; + else if (os.EqualsLiteral("WINNT 6.1")) + return OperatingSystem::Windows7; + else if (os.EqualsLiteral("WINNT 6.2")) + return OperatingSystem::Windows8; + else if (os.EqualsLiteral("WINNT 6.3")) + return OperatingSystem::Windows8_1; + else if (os.EqualsLiteral("WINNT 10.0")) + return OperatingSystem::Windows10; + else if (os.EqualsLiteral("Linux")) + return OperatingSystem::Linux; + else if (os.EqualsLiteral("Darwin 9")) + return OperatingSystem::OSX10_5; + else if (os.EqualsLiteral("Darwin 10")) + return OperatingSystem::OSX10_6; + else if (os.EqualsLiteral("Darwin 11")) + return OperatingSystem::OSX10_7; + else if (os.EqualsLiteral("Darwin 12")) + return OperatingSystem::OSX10_8; + else if (os.EqualsLiteral("Darwin 13")) + return OperatingSystem::OSX10_9; + else if (os.EqualsLiteral("Darwin 14")) + return OperatingSystem::OSX10_10; + else if (os.EqualsLiteral("Darwin 15")) + return OperatingSystem::OSX10_11; + else if (os.EqualsLiteral("Darwin 16")) + return OperatingSystem::OSX10_12; + else if (os.EqualsLiteral("Android")) + return OperatingSystem::Android; + // For historical reasons, "All" in blocklist means "All Windows" + else if (os.EqualsLiteral("All")) + return OperatingSystem::Windows; + + return OperatingSystem::Unknown; +} + +static GfxDeviceFamily* +BlacklistDevicesToDeviceFamily(nsTArray<nsCString>& devices) +{ + if (devices.Length() == 0) + return nullptr; + + // For each device, get its device ID, and return a freshly-allocated + // GfxDeviceFamily with the contents of that array. + GfxDeviceFamily* deviceIds = new GfxDeviceFamily; + + for (uint32_t i = 0; i < devices.Length(); ++i) { + // We make sure we don't add any "empty" device entries to the array, so + // we don't need to check if devices[i] is empty. + deviceIds->AppendElement(NS_ConvertUTF8toUTF16(devices[i])); + } + + return deviceIds; +} + +static int32_t +BlacklistFeatureToGfxFeature(const nsAString& aFeature) +{ + MOZ_ASSERT(!aFeature.IsEmpty()); + if (aFeature.EqualsLiteral("DIRECT2D")) + return nsIGfxInfo::FEATURE_DIRECT2D; + else if (aFeature.EqualsLiteral("DIRECT3D_9_LAYERS")) + return nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS; + else if (aFeature.EqualsLiteral("DIRECT3D_10_LAYERS")) + return nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS; + else if (aFeature.EqualsLiteral("DIRECT3D_10_1_LAYERS")) + return nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS; + else if (aFeature.EqualsLiteral("DIRECT3D_11_LAYERS")) + return nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS; + else if (aFeature.EqualsLiteral("DIRECT3D_11_ANGLE")) + return nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE; + else if (aFeature.EqualsLiteral("HARDWARE_VIDEO_DECODING")) + return nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING; + else if (aFeature.EqualsLiteral("OPENGL_LAYERS")) + return nsIGfxInfo::FEATURE_OPENGL_LAYERS; + else if (aFeature.EqualsLiteral("WEBGL_OPENGL")) + return nsIGfxInfo::FEATURE_WEBGL_OPENGL; + else if (aFeature.EqualsLiteral("WEBGL_ANGLE")) + return nsIGfxInfo::FEATURE_WEBGL_ANGLE; + else if (aFeature.EqualsLiteral("WEBGL_MSAA")) + return nsIGfxInfo::FEATURE_WEBGL_MSAA; + else if (aFeature.EqualsLiteral("STAGEFRIGHT")) + return nsIGfxInfo::FEATURE_STAGEFRIGHT; + else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_ENCODE")) + return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE; + else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_DECODE")) + return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE; + else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION")) + return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION; + else if (aFeature.EqualsLiteral("CANVAS2D_ACCELERATION")) + return nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION; + + // If we don't recognize the feature, it may be new, and something + // this version doesn't understand. So, nothing to do. This is + // different from feature not being specified at all, in which case + // this method should not get called and we should continue with the + // "all features" blocklisting. + return -1; +} + +static int32_t +BlacklistFeatureStatusToGfxFeatureStatus(const nsAString& aStatus) +{ + if (aStatus.EqualsLiteral("STATUS_OK")) + return nsIGfxInfo::FEATURE_STATUS_OK; + else if (aStatus.EqualsLiteral("BLOCKED_DRIVER_VERSION")) + return nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION; + else if (aStatus.EqualsLiteral("BLOCKED_DEVICE")) + return nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + else if (aStatus.EqualsLiteral("DISCOURAGED")) + return nsIGfxInfo::FEATURE_DISCOURAGED; + else if (aStatus.EqualsLiteral("BLOCKED_OS_VERSION")) + return nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION; + + // Do not allow it to set STATUS_UNKNOWN. Also, we are not + // expecting the "mismatch" status showing up here. + + return nsIGfxInfo::FEATURE_STATUS_OK; +} + +static VersionComparisonOp +BlacklistComparatorToComparisonOp(const nsAString& op) +{ + if (op.EqualsLiteral("LESS_THAN")) + return DRIVER_LESS_THAN; + else if (op.EqualsLiteral("BUILD_ID_LESS_THAN")) + return DRIVER_BUILD_ID_LESS_THAN; + else if (op.EqualsLiteral("LESS_THAN_OR_EQUAL")) + return DRIVER_LESS_THAN_OR_EQUAL; + else if (op.EqualsLiteral("BUILD_ID_LESS_THAN_OR_EQUAL")) + return DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL; + else if (op.EqualsLiteral("GREATER_THAN")) + return DRIVER_GREATER_THAN; + else if (op.EqualsLiteral("GREATER_THAN_OR_EQUAL")) + return DRIVER_GREATER_THAN_OR_EQUAL; + else if (op.EqualsLiteral("EQUAL")) + return DRIVER_EQUAL; + else if (op.EqualsLiteral("NOT_EQUAL")) + return DRIVER_NOT_EQUAL; + else if (op.EqualsLiteral("BETWEEN_EXCLUSIVE")) + return DRIVER_BETWEEN_EXCLUSIVE; + else if (op.EqualsLiteral("BETWEEN_INCLUSIVE")) + return DRIVER_BETWEEN_INCLUSIVE; + else if (op.EqualsLiteral("BETWEEN_INCLUSIVE_START")) + return DRIVER_BETWEEN_INCLUSIVE_START; + + return DRIVER_COMPARISON_IGNORED; +} + + +/* + Deserialize Blacklist entries from string. + e.g: + os:WINNT 6.0\tvendor:0x8086\tdevices:0x2582,0x2782\tfeature:DIRECT3D_10_LAYERS\tfeatureStatus:BLOCKED_DRIVER_VERSION\tdriverVersion:8.52.322.2202\tdriverVersionComparator:LESS_THAN_OR_EQUAL +*/ +static bool +BlacklistEntryToDriverInfo(nsCString& aBlacklistEntry, + GfxDriverInfo& aDriverInfo) +{ + // If we get an application version to be zero, something is not working + // and we are not going to bother checking the blocklist versions. + // See TestGfxWidgets.cpp for how version comparison works. + // <versionRange minVersion="42.0a1" maxVersion="45.0"></versionRange> + static mozilla::Version zeroV("0"); + static mozilla::Version appV(GfxInfoBase::GetApplicationVersion().get()); + if (appV <= zeroV) { + gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false)) << "Invalid application version " << GfxInfoBase::GetApplicationVersion().get(); + } + + nsTArray<nsCString> keyValues; + ParseString(aBlacklistEntry, '\t', keyValues); + + aDriverInfo.mRuleId = NS_LITERAL_CSTRING("FEATURE_FAILURE_DL_BLACKLIST_NO_ID"); + + for (uint32_t i = 0; i < keyValues.Length(); ++i) { + nsCString keyValue = keyValues[i]; + nsTArray<nsCString> splitted; + ParseString(keyValue, ':', splitted); + if (splitted.Length() != 2) { + // If we don't recognize the input data, we do not want to proceed. + gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false)) << "Unrecognized data " << keyValue.get(); + return false; + } + nsCString key = splitted[0]; + nsCString value = splitted[1]; + NS_ConvertUTF8toUTF16 dataValue(value); + + if (value.Length() == 0) { + // Safety check for empty values. + gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false)) << "Empty value for " << key.get(); + return false; + } + + if (key.EqualsLiteral("blockID")) { + nsCString blockIdStr = NS_LITERAL_CSTRING("FEATURE_FAILURE_DL_BLACKLIST_") + value; + aDriverInfo.mRuleId = blockIdStr.get(); + } else if (key.EqualsLiteral("os")) { + aDriverInfo.mOperatingSystem = BlacklistOSToOperatingSystem(dataValue); + } else if (key.EqualsLiteral("osversion")) { + aDriverInfo.mOperatingSystemVersion = strtoul(value.get(), nullptr, 10); + } else if (key.EqualsLiteral("vendor")) { + aDriverInfo.mAdapterVendor = dataValue; + } else if (key.EqualsLiteral("feature")) { + aDriverInfo.mFeature = BlacklistFeatureToGfxFeature(dataValue); + if (aDriverInfo.mFeature < 0) { + // If we don't recognize the feature, we do not want to proceed. + gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false)) << "Unrecognized feature " << value.get(); + return false; + } + } else if (key.EqualsLiteral("featureStatus")) { + aDriverInfo.mFeatureStatus = BlacklistFeatureStatusToGfxFeatureStatus(dataValue); + } else if (key.EqualsLiteral("driverVersion")) { + uint64_t version; + if (ParseDriverVersion(dataValue, &version)) + aDriverInfo.mDriverVersion = version; + } else if (key.EqualsLiteral("driverVersionMax")) { + uint64_t version; + if (ParseDriverVersion(dataValue, &version)) + aDriverInfo.mDriverVersionMax = version; + } else if (key.EqualsLiteral("driverVersionComparator")) { + aDriverInfo.mComparisonOp = BlacklistComparatorToComparisonOp(dataValue); + } else if (key.EqualsLiteral("model")) { + aDriverInfo.mModel = dataValue; + } else if (key.EqualsLiteral("product")) { + aDriverInfo.mProduct = dataValue; + } else if (key.EqualsLiteral("manufacturer")) { + aDriverInfo.mManufacturer = dataValue; + } else if (key.EqualsLiteral("hardware")) { + aDriverInfo.mHardware = dataValue; + } else if (key.EqualsLiteral("versionRange")) { + nsTArray<nsCString> versionRange; + ParseString(value, ',', versionRange); + if (versionRange.Length() != 2) { + gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false)) << "Unrecognized versionRange " << value.get(); + return false; + } + nsCString minValue = versionRange[0]; + nsCString maxValue = versionRange[1]; + + mozilla::Version minV(minValue.get()); + mozilla::Version maxV(maxValue.get()); + + if (minV > zeroV && !(appV >= minV)) { + // The version of the application is less than the minimal version + // this blocklist entry applies to, so we can just ignore it by + // returning false and letting the caller deal with it. + return false; + } + if (maxV > zeroV && !(appV <= maxV)) { + // The version of the application is more than the maximal version + // this blocklist entry applies to, so we can just ignore it by + // returning false and letting the caller deal with it. + return false; + } + } else if (key.EqualsLiteral("devices")) { + nsTArray<nsCString> devices; + ParseString(value, ',', devices); + GfxDeviceFamily* deviceIds = BlacklistDevicesToDeviceFamily(devices); + if (deviceIds) { + // Get GfxDriverInfo to adopt the devices array we created. + aDriverInfo.mDeleteDevices = true; + aDriverInfo.mDevices = deviceIds; + } + } + // We explicitly ignore unknown elements. + } + + return true; +} + +static void +BlacklistEntriesToDriverInfo(nsTArray<nsCString>& aBlacklistEntries, + nsTArray<GfxDriverInfo>& aDriverInfo) +{ + aDriverInfo.Clear(); + aDriverInfo.SetLength(aBlacklistEntries.Length()); + + for (uint32_t i = 0; i < aBlacklistEntries.Length(); ++i) { + nsCString blacklistEntry = aBlacklistEntries[i]; + GfxDriverInfo di; + if (BlacklistEntryToDriverInfo(blacklistEntry, di)) { + aDriverInfo[i] = di; + // Prevent di falling out of scope from destroying the devices. + di.mDeleteDevices = false; + } + } +} + +NS_IMETHODIMP +GfxInfoBase::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + if (strcmp(aTopic, "blocklist-data-gfxItems") == 0) { + nsTArray<GfxDriverInfo> driverInfo; + nsTArray<nsCString> blacklistEntries; + nsCString utf8Data = NS_ConvertUTF16toUTF8(aData); + if (utf8Data.Length() > 0) { + ParseString(utf8Data, '\n', blacklistEntries); + } + BlacklistEntriesToDriverInfo(blacklistEntries, driverInfo); + EvaluateDownloadedBlacklist(driverInfo); + } + + return NS_OK; +} + +GfxInfoBase::GfxInfoBase() + : mMutex("GfxInfoBase") +{ +} + +GfxInfoBase::~GfxInfoBase() +{ +} + +nsresult +GfxInfoBase::Init() +{ + InitGfxDriverInfoShutdownObserver(); + gfxPrefs::GetSingleton(); + MediaPrefs::GetSingleton(); + + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + if (os) { + os->AddObserver(this, "blocklist-data-gfxItems", true); + } + + return NS_OK; +} + +NS_IMETHODIMP +GfxInfoBase::GetFeatureStatus(int32_t aFeature, nsACString& aFailureId, int32_t* aStatus) +{ + int32_t blocklistAll = gfxPrefs::BlocklistAll(); + if (blocklistAll > 0) { + gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false)) << "Forcing blocklisting all features"; + *aStatus = FEATURE_BLOCKED_DEVICE; + aFailureId = "FEATURE_FAILURE_BLOCK_ALL"; + return NS_OK; + } else if (blocklistAll < 0) { + gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false)) << "Ignoring any feature blocklisting."; + *aStatus = FEATURE_STATUS_OK; + return NS_OK; + } + + if (GetPrefValueForFeature(aFeature, *aStatus, aFailureId)) { + return NS_OK; + } + + if (XRE_IsContentProcess()) { + // Delegate to the parent process. + mozilla::dom::ContentChild* cc = mozilla::dom::ContentChild::GetSingleton(); + bool success; + nsCString remoteFailureId; + cc->SendGetGraphicsFeatureStatus(aFeature, aStatus, &remoteFailureId, &success); + aFailureId = remoteFailureId; + return success ? NS_OK : NS_ERROR_FAILURE; + } + + nsString version; + nsTArray<GfxDriverInfo> driverInfo; + nsresult rv = GetFeatureStatusImpl(aFeature, aStatus, version, driverInfo, aFailureId); + return rv; +} + +// Matching OS go somewhat beyond the simple equality check because of the +// "All Windows" and "All OS X" variations. +// +// aBlockedOS is describing the system(s) we are trying to block. +// aSystemOS is describing the system we are running on. +// +// aSystemOS should not be "Windows" or "OSX" - it should be set to +// a particular version instead. +// However, it is valid for aBlockedOS to be one of those generic values, +// as we could be blocking all of the versions. +inline bool +MatchingOperatingSystems(OperatingSystem aBlockedOS, OperatingSystem aSystemOS) +{ + MOZ_ASSERT(aSystemOS != OperatingSystem::Windows && + aSystemOS != OperatingSystem::OSX); + + // If the block entry OS is unknown, it doesn't match + if (aBlockedOS == OperatingSystem::Unknown) { + return false; + } + +#if defined (XP_WIN) + if (aBlockedOS == OperatingSystem::Windows) { + // We do want even "unknown" aSystemOS to fall under "all windows" + return true; + } +#endif + +#if defined (XP_MACOSX) + if (aBlockedOS == OperatingSystem::OSX) { + // We do want even "unknown" aSystemOS to fall under "all OS X" + return true; + } +#endif + + return aSystemOS == aBlockedOS; +} + +int32_t +GfxInfoBase::FindBlocklistedDeviceInList(const nsTArray<GfxDriverInfo>& info, + nsAString& aSuggestedVersion, + int32_t aFeature, + nsACString& aFailureId, + OperatingSystem os) +{ + int32_t status = nsIGfxInfo::FEATURE_STATUS_UNKNOWN; + + uint32_t i = 0; + for (; i < info.Length(); i++) { + // Do the operating system check first, no point in getting the driver + // info if we won't need to use it. + if (!MatchingOperatingSystems(info[i].mOperatingSystem, os)) { + continue; + } + + if (info[i].mOperatingSystemVersion && info[i].mOperatingSystemVersion != OperatingSystemVersion()) { + continue; + } + + // XXX: it would be better not to do this everytime round the loop + nsAutoString adapterVendorID; + nsAutoString adapterDeviceID; + nsAutoString adapterDriverVersionString; + if (info[i].mGpu2) { + if (NS_FAILED(GetAdapterVendorID2(adapterVendorID)) || + NS_FAILED(GetAdapterDeviceID2(adapterDeviceID)) || + NS_FAILED(GetAdapterDriverVersion2(adapterDriverVersionString))) + { + return 0; + } + } else { + if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) || + NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) || + NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString))) + { + return 0; + } + } + +#if defined(XP_WIN) || defined(ANDROID) + uint64_t driverVersion; + ParseDriverVersion(adapterDriverVersionString, &driverVersion); +#endif + + if (!info[i].mAdapterVendor.Equals(GfxDriverInfo::GetDeviceVendor(VendorAll), nsCaseInsensitiveStringComparator()) && + !info[i].mAdapterVendor.Equals(adapterVendorID, nsCaseInsensitiveStringComparator())) { + continue; + } + + if (info[i].mDevices != GfxDriverInfo::allDevices && info[i].mDevices->Length()) { + bool deviceMatches = false; + for (uint32_t j = 0; j < info[i].mDevices->Length(); j++) { + if ((*info[i].mDevices)[j].Equals(adapterDeviceID, nsCaseInsensitiveStringComparator())) { + deviceMatches = true; + break; + } + } + + if (!deviceMatches) { + continue; + } + } + + bool match = false; + + if (!info[i].mHardware.IsEmpty() && !info[i].mHardware.Equals(Hardware())) { + continue; + } + if (!info[i].mModel.IsEmpty() && !info[i].mModel.Equals(Model())) { + continue; + } + if (!info[i].mProduct.IsEmpty() && !info[i].mProduct.Equals(Product())) { + continue; + } + if (!info[i].mManufacturer.IsEmpty() && !info[i].mManufacturer.Equals(Manufacturer())) { + continue; + } + +#if defined(XP_WIN) || defined(ANDROID) + switch (info[i].mComparisonOp) { + case DRIVER_LESS_THAN: + match = driverVersion < info[i].mDriverVersion; + break; + case DRIVER_BUILD_ID_LESS_THAN: + match = (driverVersion & 0xFFFF) < info[i].mDriverVersion; + break; + case DRIVER_LESS_THAN_OR_EQUAL: + match = driverVersion <= info[i].mDriverVersion; + break; + case DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL: + match = (driverVersion & 0xFFFF) <= info[i].mDriverVersion; + break; + case DRIVER_GREATER_THAN: + match = driverVersion > info[i].mDriverVersion; + break; + case DRIVER_GREATER_THAN_OR_EQUAL: + match = driverVersion >= info[i].mDriverVersion; + break; + case DRIVER_EQUAL: + match = driverVersion == info[i].mDriverVersion; + break; + case DRIVER_NOT_EQUAL: + match = driverVersion != info[i].mDriverVersion; + break; + case DRIVER_BETWEEN_EXCLUSIVE: + match = driverVersion > info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax; + break; + case DRIVER_BETWEEN_INCLUSIVE: + match = driverVersion >= info[i].mDriverVersion && driverVersion <= info[i].mDriverVersionMax; + break; + case DRIVER_BETWEEN_INCLUSIVE_START: + match = driverVersion >= info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax; + break; + case DRIVER_COMPARISON_IGNORED: + // We don't have a comparison op, so we match everything. + match = true; + break; + default: + NS_WARNING("Bogus op in GfxDriverInfo"); + break; + } +#else + // We don't care what driver version it was. We only check OS version and if + // the device matches. + match = true; +#endif + + if (match || info[i].mDriverVersion == GfxDriverInfo::allDriverVersions) { + if (info[i].mFeature == GfxDriverInfo::allFeatures || + info[i].mFeature == aFeature) + { + status = info[i].mFeatureStatus; + if (!info[i].mRuleId.IsEmpty()) { + aFailureId = info[i].mRuleId.get(); + } else { + aFailureId = "FEATURE_FAILURE_DL_BLACKLIST_NO_ID"; + } + break; + } + } + } + +#if defined(XP_WIN) + // As a very special case, we block D2D on machines with an NVidia 310M GPU + // as either the primary or secondary adapter. D2D is also blocked when the + // NV 310M is the primary adapter (using the standard blocklisting mechanism). + // If the primary GPU already matched something in the blocklist then we + // ignore this special rule. See bug 1008759. + if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN && + (aFeature == nsIGfxInfo::FEATURE_DIRECT2D)) { + nsAutoString adapterVendorID2; + nsAutoString adapterDeviceID2; + if ((!NS_FAILED(GetAdapterVendorID2(adapterVendorID2))) && + (!NS_FAILED(GetAdapterDeviceID2(adapterDeviceID2)))) + { + nsAString &nvVendorID = (nsAString &)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA); + const nsString nv310mDeviceId = NS_LITERAL_STRING("0x0A70"); + if (nvVendorID.Equals(adapterVendorID2, nsCaseInsensitiveStringComparator()) && + nv310mDeviceId.Equals(adapterDeviceID2, nsCaseInsensitiveStringComparator())) { + status = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; + aFailureId = "FEATURE_FAILURE_D2D_NV310M_BLOCK"; + } + } + } + + // Depends on Windows driver versioning. We don't pass a GfxDriverInfo object + // back to the Windows handler, so we must handle this here. + if (status == FEATURE_BLOCKED_DRIVER_VERSION) { + if (info[i].mSuggestedVersion) { + aSuggestedVersion.AppendPrintf("%s", info[i].mSuggestedVersion); + } else if (info[i].mComparisonOp == DRIVER_LESS_THAN && + info[i].mDriverVersion != GfxDriverInfo::allDriverVersions) + { + aSuggestedVersion.AppendPrintf("%lld.%lld.%lld.%lld", + (info[i].mDriverVersion & 0xffff000000000000) >> 48, + (info[i].mDriverVersion & 0x0000ffff00000000) >> 32, + (info[i].mDriverVersion & 0x00000000ffff0000) >> 16, + (info[i].mDriverVersion & 0x000000000000ffff)); + } + } +#endif + + return status; +} + +nsresult +GfxInfoBase::GetFeatureStatusImpl(int32_t aFeature, + int32_t* aStatus, + nsAString& aSuggestedVersion, + const nsTArray<GfxDriverInfo>& aDriverInfo, + nsACString& aFailureId, + OperatingSystem* aOS /* = nullptr */) +{ + if (aFeature <= 0) { + gfxWarning() << "Invalid feature <= 0"; + return NS_OK; + } + + if (*aStatus != nsIGfxInfo::FEATURE_STATUS_UNKNOWN) { + // Terminate now with the status determined by the derived type (OS-specific + // code). + return NS_OK; + } + + // If an operating system was provided by the derived GetFeatureStatusImpl, + // grab it here. Otherwise, the OS is unknown. + OperatingSystem os = (aOS ? *aOS : OperatingSystem::Unknown); + + nsAutoString adapterVendorID; + nsAutoString adapterDeviceID; + nsAutoString adapterDriverVersionString; + if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) || + NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) || + NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString))) + { + aFailureId = "FEATURE_FAILURE_CANT_RESOLVE_ADAPTER"; + *aStatus = FEATURE_BLOCKED_DEVICE; + return NS_OK; + } + + // Check if the device is blocked from the downloaded blocklist. If not, check + // the static list after that. This order is used so that we can later escape + // out of static blocks (i.e. if we were wrong or something was patched, we + // can back out our static block without doing a release). + int32_t status; + if (aDriverInfo.Length()) { + status = FindBlocklistedDeviceInList(aDriverInfo, aSuggestedVersion, aFeature, aFailureId, os); + } else { + if (!mDriverInfo) { + mDriverInfo = new nsTArray<GfxDriverInfo>(); + } + status = FindBlocklistedDeviceInList(GetGfxDriverInfo(), aSuggestedVersion, aFeature, aFailureId, os); + } + + // It's now done being processed. It's safe to set the status to STATUS_OK. + if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN) { + *aStatus = nsIGfxInfo::FEATURE_STATUS_OK; + } else { + *aStatus = status; + } + + return NS_OK; +} + +NS_IMETHODIMP +GfxInfoBase::GetFeatureSuggestedDriverVersion(int32_t aFeature, + nsAString& aVersion) +{ + nsCString version; + if (GetPrefValueForDriverVersion(version)) { + aVersion = NS_ConvertASCIItoUTF16(version); + return NS_OK; + } + + int32_t status; + nsCString discardFailureId; + nsTArray<GfxDriverInfo> driverInfo; + return GetFeatureStatusImpl(aFeature, &status, aVersion, driverInfo, discardFailureId); +} + + +NS_IMETHODIMP +GfxInfoBase::GetWebGLParameter(const nsAString& aParam, + nsAString& aResult) +{ + return GfxInfoWebGL::GetWebGLParameter(aParam, aResult); +} + +void +GfxInfoBase::EvaluateDownloadedBlacklist(nsTArray<GfxDriverInfo>& aDriverInfo) +{ + int32_t features[] = { + nsIGfxInfo::FEATURE_DIRECT2D, + nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS, + nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS, + nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS, + nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS, + nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE, + nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING, + nsIGfxInfo::FEATURE_OPENGL_LAYERS, + nsIGfxInfo::FEATURE_WEBGL_OPENGL, + nsIGfxInfo::FEATURE_WEBGL_ANGLE, + nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE, + nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE, + nsIGfxInfo::FEATURE_WEBGL_MSAA, + nsIGfxInfo::FEATURE_STAGEFRIGHT, + nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION, + nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION, + 0 + }; + + // For every feature we know about, we evaluate whether this blacklist has a + // non-STATUS_OK status. If it does, we set the pref we evaluate in + // GetFeatureStatus above, so we don't need to hold on to this blacklist + // anywhere permanent. + int i = 0; + while (features[i]) { + int32_t status; + nsCString failureId; + nsAutoString suggestedVersion; + if (NS_SUCCEEDED(GetFeatureStatusImpl(features[i], &status, + suggestedVersion, + aDriverInfo, + failureId))) { + switch (status) { + default: + case nsIGfxInfo::FEATURE_STATUS_OK: + RemovePrefForFeature(features[i]); + break; + + case nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION: + if (!suggestedVersion.IsEmpty()) { + SetPrefValueForDriverVersion(suggestedVersion); + } else { + RemovePrefForDriverVersion(); + } + MOZ_FALLTHROUGH; + + case nsIGfxInfo::FEATURE_BLOCKED_MISMATCHED_VERSION: + case nsIGfxInfo::FEATURE_BLOCKED_DEVICE: + case nsIGfxInfo::FEATURE_DISCOURAGED: + case nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION: + SetPrefValueForFeature(features[i], status, failureId); + break; + } + } + + ++i; + } +} + +NS_IMETHODIMP_(void) +GfxInfoBase::LogFailure(const nsACString &failure) +{ + // gfxCriticalError has a mutex lock of its own, so we may not actually + // need this lock. ::GetFailures() accesses the data but the LogForwarder + // will not return the copy of the logs unless it can get the same lock + // that gfxCriticalError uses. Still, that is so much of an implementation + // detail that it's nicer to just add an extra lock here and in ::GetFailures() + MutexAutoLock lock(mMutex); + + // By default, gfxCriticalError asserts; make it not assert in this case. + gfxCriticalError(CriticalLog::DefaultOptions(false)) << "(LF) " << failure.BeginReading(); +} + +/* XPConnect method of returning arrays is very ugly. Would not recommend. */ +NS_IMETHODIMP GfxInfoBase::GetFailures(uint32_t* failureCount, + int32_t** indices, + char ***failures) +{ + MutexAutoLock lock(mMutex); + + NS_ENSURE_ARG_POINTER(failureCount); + NS_ENSURE_ARG_POINTER(failures); + + *failures = nullptr; + *failureCount = 0; + + // indices is "allowed" to be null, the caller may not care about them, + // although calling from JS doesn't seem to get us there. + if (indices) *indices = nullptr; + + LogForwarder* logForwarder = Factory::GetLogForwarder(); + if (!logForwarder) { + return NS_ERROR_UNEXPECTED; + } + + // There are two stirng copies in this method, starting with this one. We are + // assuming this is not a big deal, as the size of the array should be small + // and the strings in it should be small as well (the error messages in the + // code.) The second copy happens with the Clone() calls. Technically, + // we don't need the mutex lock after the StringVectorCopy() call. + LoggingRecord loggedStrings = logForwarder->LoggingRecordCopy(); + *failureCount = loggedStrings.size(); + + if (*failureCount != 0) { + *failures = (char**)moz_xmalloc(*failureCount * sizeof(char*)); + if (!(*failures)) { + return NS_ERROR_OUT_OF_MEMORY; + } + if (indices) { + *indices = (int32_t*)moz_xmalloc(*failureCount * sizeof(int32_t)); + if (!(*indices)) { + free(*failures); + *failures = nullptr; + return NS_ERROR_OUT_OF_MEMORY; + } + } + + /* copy over the failure messages into the array we just allocated */ + LoggingRecord::const_iterator it; + uint32_t i=0; + for(it = loggedStrings.begin() ; it != loggedStrings.end(); ++it, i++) { + (*failures)[i] = (char*)nsMemory::Clone(Get<1>(*it).c_str(), Get<1>(*it).size() + 1); + if (indices) (*indices)[i] = Get<0>(*it); + + if (!(*failures)[i]) { + /* <sarcasm> I'm too afraid to use an inline function... </sarcasm> */ + NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, (*failures)); + *failureCount = i; + return NS_ERROR_OUT_OF_MEMORY; + } + } + } + + return NS_OK; +} + +nsTArray<GfxInfoCollectorBase*> *sCollectors; + +static void +InitCollectors() +{ + if (!sCollectors) + sCollectors = new nsTArray<GfxInfoCollectorBase*>; +} + +nsresult GfxInfoBase::GetInfo(JSContext* aCx, JS::MutableHandle<JS::Value> aResult) +{ + InitCollectors(); + InfoObject obj(aCx); + + for (uint32_t i = 0; i < sCollectors->Length(); i++) { + (*sCollectors)[i]->GetInfo(obj); + } + + // Some example property definitions + // obj.DefineProperty("wordCacheSize", gfxTextRunWordCache::Count()); + // obj.DefineProperty("renderer", mRendererIDsString); + // obj.DefineProperty("five", 5); + + if (!obj.mOk) { + return NS_ERROR_FAILURE; + } + + aResult.setObject(*obj.mObj); + return NS_OK; +} + +nsAutoCString gBaseAppVersion; + +const nsCString& +GfxInfoBase::GetApplicationVersion() +{ + static bool versionInitialized = false; + if (!versionInitialized) { + // If we fail to get the version, we will not try again. + versionInitialized = true; + + // Get the version from xpcom/system/nsIXULAppInfo.idl + nsCOMPtr<nsIXULAppInfo> app = do_GetService("@mozilla.org/xre/app-info;1"); + if (app) { + app->GetVersion(gBaseAppVersion); + } + } + return gBaseAppVersion; +} + +void +GfxInfoBase::AddCollector(GfxInfoCollectorBase* collector) +{ + InitCollectors(); + sCollectors->AppendElement(collector); +} + +void +GfxInfoBase::RemoveCollector(GfxInfoCollectorBase* collector) +{ + InitCollectors(); + for (uint32_t i = 0; i < sCollectors->Length(); i++) { + if ((*sCollectors)[i] == collector) { + sCollectors->RemoveElementAt(i); + break; + } + } + if (sCollectors->IsEmpty()) { + delete sCollectors; + sCollectors = nullptr; + } +} + +NS_IMETHODIMP +GfxInfoBase::GetMonitors(JSContext* aCx, JS::MutableHandleValue aResult) +{ + JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, 0)); + + nsresult rv = FindMonitors(aCx, array); + if (NS_FAILED(rv)) { + return rv; + } + + aResult.setObject(*array); + return NS_OK; +} + +static const char* +GetLayersBackendName(layers::LayersBackend aBackend) +{ + switch (aBackend) { + case layers::LayersBackend::LAYERS_NONE: + return "none"; + case layers::LayersBackend::LAYERS_OPENGL: + return "opengl"; + case layers::LayersBackend::LAYERS_D3D9: + return "d3d9"; + case layers::LayersBackend::LAYERS_D3D11: + return "d3d11"; + case layers::LayersBackend::LAYERS_CLIENT: + return "client"; + case layers::LayersBackend::LAYERS_BASIC: + return "basic"; + default: + MOZ_ASSERT_UNREACHABLE("unknown layers backend"); + return "unknown"; + } +} + +static inline bool +SetJSPropertyString(JSContext* aCx, JS::Handle<JSObject*> aObj, + const char* aProp, const char* aString) +{ + JS::Rooted<JSString*> str(aCx, JS_NewStringCopyZ(aCx, aString)); + if (!str) { + return false; + } + + JS::Rooted<JS::Value> val(aCx, JS::StringValue(str)); + return JS_SetProperty(aCx, aObj, aProp, val); +} + +template <typename T> +static inline bool +AppendJSElement(JSContext* aCx, JS::Handle<JSObject*> aObj, const T& aValue) +{ + uint32_t index; + if (!JS_GetArrayLength(aCx, aObj, &index)) { + return false; + } + return JS_SetElement(aCx, aObj, index, aValue); +} + +nsresult +GfxInfoBase::GetFeatures(JSContext* aCx, JS::MutableHandle<JS::Value> aOut) +{ + JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); + if (!obj) { + return NS_ERROR_OUT_OF_MEMORY; + } + aOut.setObject(*obj); + + layers::LayersBackend backend = gfxPlatform::Initialized() + ? gfxPlatform::GetPlatform()->GetCompositorBackend() + : layers::LayersBackend::LAYERS_NONE; + const char* backendName = GetLayersBackendName(backend); + SetJSPropertyString(aCx, obj, "compositor", backendName); + + // If graphics isn't initialized yet, just stop now. + if (!gfxPlatform::Initialized()) { + return NS_OK; + } + + DescribeFeatures(aCx, obj); + return NS_OK; +} + +nsresult GfxInfoBase::GetFeatureLog(JSContext* aCx, JS::MutableHandle<JS::Value> aOut) +{ + JS::Rooted<JSObject*> containerObj(aCx, JS_NewPlainObject(aCx)); + if (!containerObj) { + return NS_ERROR_OUT_OF_MEMORY; + } + aOut.setObject(*containerObj); + + JS::Rooted<JSObject*> featureArray(aCx, JS_NewArrayObject(aCx, 0)); + if (!featureArray) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // Collect features. + gfxConfig::ForEachFeature([&](const char* aName, + const char* aDescription, + FeatureState& aFeature) -> void { + JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); + if (!obj) { + return; + } + if (!SetJSPropertyString(aCx, obj, "name", aName) || + !SetJSPropertyString(aCx, obj, "description", aDescription) || + !SetJSPropertyString(aCx, obj, "status", FeatureStatusToString(aFeature.GetValue()))) + { + return; + } + + JS::Rooted<JS::Value> log(aCx); + if (!BuildFeatureStateLog(aCx, aFeature, &log)) { + return; + } + if (!JS_SetProperty(aCx, obj, "log", log)) { + return; + } + + if (!AppendJSElement(aCx, featureArray, obj)) { + return; + } + }); + + JS::Rooted<JSObject*> fallbackArray(aCx, JS_NewArrayObject(aCx, 0)); + if (!fallbackArray) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // Collect fallbacks. + gfxConfig::ForEachFallback([&](const char* aName, const char* aMessage) -> void { + JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); + if (!obj) { + return; + } + + if (!SetJSPropertyString(aCx, obj, "name", aName) || + !SetJSPropertyString(aCx, obj, "message", aMessage)) + { + return; + } + + if (!AppendJSElement(aCx, fallbackArray, obj)) { + return; + } + }); + + JS::Rooted<JS::Value> val(aCx); + + val = JS::ObjectValue(*featureArray); + JS_SetProperty(aCx, containerObj, "features", val); + + val = JS::ObjectValue(*fallbackArray); + JS_SetProperty(aCx, containerObj, "fallbacks", val); + + return NS_OK; +} + +bool +GfxInfoBase::BuildFeatureStateLog(JSContext* aCx, const FeatureState& aFeature, + JS::MutableHandle<JS::Value> aOut) +{ + JS::Rooted<JSObject*> log(aCx, JS_NewArrayObject(aCx, 0)); + if (!log) { + return false; + } + aOut.setObject(*log); + + aFeature.ForEachStatusChange([&](const char* aType, + FeatureStatus aStatus, + const char* aMessage) -> void { + JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); + if (!obj) { + return; + } + + if (!SetJSPropertyString(aCx, obj, "type", aType) || + !SetJSPropertyString(aCx, obj, "status", FeatureStatusToString(aStatus)) || + (aMessage && !SetJSPropertyString(aCx, obj, "message", aMessage))) + { + return; + } + + if (!AppendJSElement(aCx, log, obj)) { + return; + } + }); + + return true; +} + +void +GfxInfoBase::DescribeFeatures(JSContext* aCx, JS::Handle<JSObject*> aObj) +{ +} + +bool +GfxInfoBase::InitFeatureObject(JSContext* aCx, + JS::Handle<JSObject*> aContainer, + const char* aName, + int32_t aFeature, + Maybe<mozilla::gfx::FeatureStatus> aFeatureStatus, + JS::MutableHandle<JSObject*> aOutObj) +{ + JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); + if (!obj) { + return false; + } + + nsCString failureId = NS_LITERAL_CSTRING("OK"); + int32_t unused; + if (!NS_SUCCEEDED(GetFeatureStatus(aFeature, failureId, &unused))) { + return false; + } + + // Set "status". + if (aFeatureStatus) { + const char* status = FeatureStatusToString(aFeatureStatus.value()); + + JS::Rooted<JSString*> str(aCx, JS_NewStringCopyZ(aCx, status)); + JS::Rooted<JS::Value> val(aCx, JS::StringValue(str)); + JS_SetProperty(aCx, obj, "status", val); + } + + // Add the feature object to the container. + { + JS::Rooted<JS::Value> val(aCx, JS::ObjectValue(*obj)); + JS_SetProperty(aCx, aContainer, aName, val); + } + + aOutObj.set(obj); + return true; +} + +nsresult +GfxInfoBase::GetActiveCrashGuards(JSContext* aCx, JS::MutableHandle<JS::Value> aOut) +{ + JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, 0)); + if (!array) { + return NS_ERROR_OUT_OF_MEMORY; + } + aOut.setObject(*array); + + DriverCrashGuard::ForEachActiveCrashGuard([&](const char* aName, + const char* aPrefName) -> void { + JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); + if (!obj) { + return; + } + if (!SetJSPropertyString(aCx, obj, "type", aName)) { + return; + } + if (!SetJSPropertyString(aCx, obj, "prefName", aPrefName)) { + return; + } + if (!AppendJSElement(aCx, array, obj)) { + return; + } + }); + + return NS_OK; +} + +NS_IMETHODIMP +GfxInfoBase::GetContentBackend(nsAString & aContentBackend) +{ + BackendType backend = gfxPlatform::GetPlatform()->GetDefaultContentBackend(); + nsString outStr; + + switch (backend) { + case BackendType::DIRECT2D1_1: { + outStr.AppendPrintf("Direct2D 1.1"); + break; + } + case BackendType::SKIA: { + outStr.AppendPrintf("Skia"); + break; + } + case BackendType::CAIRO: { + outStr.AppendPrintf("Cairo"); + break; + } + default: + return NS_ERROR_FAILURE; + } + + aContentBackend.Assign(outStr); + return NS_OK; +} + +GfxInfoCollectorBase::GfxInfoCollectorBase() +{ + GfxInfoBase::AddCollector(this); +} + +GfxInfoCollectorBase::~GfxInfoCollectorBase() +{ + GfxInfoBase::RemoveCollector(this); +} |