Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-17 06:09:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1544105 - Part 1. Expose new driver vendor field for the graphics blocklist. r=jrmuizel

Browse Source 
This reunifies the behaviour changed in bug 1294232 to ensure that the
vendor ID of GfxInfo is the same between graphics hardware. Vendor ID
should always represent Intel, Nvidia, ATI, etc such that callers can
reason about the performance characteristics without being exposed to
the driver implementation for that platform. Now we split off the more
detailed driver information into the "driver vendor" which will contain
more information, such as what implementation is being used (e.g.
mesa/i965 for modern Intel graphics cards). This field is exposed to the
blocklist and will be useful for allowing different rules for different
driver implementations.

We also now provide a default implementation for
GfxInfoBase::FindMonitors for platforms missing support. This will just
list the primary screen size used without listing secondary monitors,
refresh rate, and such.

Differential Revision: https://phabricator.services.mozilla.com/D29471
This commit is contained in:
Andrew Osmond 2019-04-30 16:29:18 -04:00
parent f1bc51d3d7
commit f289a95270
14 changed files with 309 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
gfx/thebes/gfxPlatform.cpp
View File

@ -2595,8 +2595,7 @@ static FeatureState& WebRenderHardwareQualificationStatus(
}
#endif
#ifdef NIGHTLY_BUILD
} else if (adapterVendorID == u"0x8086" ||
adapterVendorID == u"mesa/i965") { // Intel
} else if (adapterVendorID == u"0x8086") { // Intel
const uint16_t supportedDevices[] = {
// skylake gt2+
0x1912,
@ -2620,6 +2619,7 @@ static FeatureState& WebRenderHardwareQualificationStatus(
// kabylake gt2+
0x5912,
0x5916,
0x5917,
0x591a,
0x591b,
0x591c,
@ -2669,7 +2669,11 @@ static FeatureState& WebRenderHardwareQualificationStatus(
featureWebRenderQualified.Disable(
FeatureStatus::Blocked, "Device too old",
NS_LITERAL_CSTRING("FEATURE_FAILURE_DEVICE_TOO_OLD"));
} else if (adapterVendorID == u"mesa/i965") {
}
# ifdef MOZ_WIDGET_GTK
else {
// Performance is not great on 4k screens with WebRender + Linux.
// Disable it for now if it is too large.
const int32_t maxPixels = 3440 * 1440; // UWQHD
int32_t pixels = aScreenSize.width * aScreenSize.height;
if (pixels > maxPixels) {
@ -2682,7 +2686,8 @@ static FeatureState& WebRenderHardwareQualificationStatus(
NS_LITERAL_CSTRING("FEATURE_FAILURE_SCREEN_SIZE_UNKNOWN"));
}
}
#endif
# endif // MOZ_WIDGET_GTK
#endif // NIGHTLY_BUILD
} else {
featureWebRenderQualified.Disable(
FeatureStatus::Blocked, "Unsupported vendor",

40
widget/GfxDriverInfo.cpp
View File

@ -16,11 +16,13 @@ GfxDeviceFamily* const GfxDriverInfo::allDevices = nullptr;
GfxDeviceFamily* GfxDriverInfo::sDeviceFamilies[DeviceFamilyMax];
nsAString* GfxDriverInfo::sDeviceVendors[DeviceVendorMax];
nsAString* GfxDriverInfo::sDriverVendors[DriverVendorMax];
GfxDriverInfo::GfxDriverInfo()
: mOperatingSystem(OperatingSystem::Unknown),
mOperatingSystemVersion(0),
mAdapterVendor(GfxDriverInfo::GetDeviceVendor(VendorAll)),
mDriverVendor(GfxDriverInfo::GetDriverVendor(DriverVendorAll)),
mDevices(allDevices),
mDeleteDevices(false),
mFeature(allFeatures),
@ -32,7 +34,8 @@ GfxDriverInfo::GfxDriverInfo()
mRuleId(nullptr),
mGpu2(false) {}
GfxDriverInfo::GfxDriverInfo(OperatingSystem os, nsAString& vendor,
GfxDriverInfo::GfxDriverInfo(OperatingSystem os, const nsAString& vendor,
const nsAString& driverVendor,
GfxDeviceFamily* devices, int32_t feature,
int32_t featureStatus, VersionComparisonOp op,
uint64_t driverVersion, const char* ruleId,
@ -42,6 +45,7 @@ GfxDriverInfo::GfxDriverInfo(OperatingSystem os, nsAString& vendor,
: mOperatingSystem(os),
mOperatingSystemVersion(0),
mAdapterVendor(vendor),
mDriverVendor(driverVendor),
mDevices(devices),
mDeleteDevices(ownDevices),
mFeature(feature),
@ -57,6 +61,7 @@ GfxDriverInfo::GfxDriverInfo(const GfxDriverInfo& aOrig)
: mOperatingSystem(aOrig.mOperatingSystem),
mOperatingSystemVersion(aOrig.mOperatingSystemVersion),
mAdapterVendor(aOrig.mAdapterVendor),
mDriverVendor(aOrig.mDriverVendor),
mFeature(aOrig.mFeature),
mFeatureStatus(aOrig.mFeatureStatus),
mComparisonOp(aOrig.mComparisonOp),
@ -381,14 +386,37 @@ const nsAString& GfxDriverInfo::GetDeviceVendor(DeviceVendor id) {
// Choose an arbitrary Qualcomm PCI VENdor ID for now.
// TODO: This should be "QCOM" when Windows device ID parsing is reworked.
DECLARE_VENDOR_ID(VendorQualcomm, "0x5143");
DECLARE_VENDOR_ID(VendorMesaAll, "mesa/all");
DECLARE_VENDOR_ID(VendorMesaLLVMPipe, "mesa/llvmpipe");
DECLARE_VENDOR_ID(VendorMesaSoftPipe, "mesa/softpipe");
DECLARE_VENDOR_ID(VendorMesaSWRast, "mesa/swrast");
DECLARE_VENDOR_ID(VendorMesaUnknown, "mesa/unknown");
// Suppress a warning.
DECLARE_VENDOR_ID(DeviceVendorMax, "");
}
return *sDeviceVendors[id];
}
// Macro for assigning a driver vendor id to a string.
#define DECLARE_DRIVER_VENDOR_ID(name, driverVendorId) \
case name: \
sDriverVendors[id]->AssignLiteral(driverVendorId); \
break;
const nsAString& GfxDriverInfo::GetDriverVendor(DriverVendor id) {
NS_ASSERTION(id >= 0 && id < DriverVendorMax,
"DriverVendor id is out of range");
if (sDriverVendors[id]) return *sDriverVendors[id];
sDriverVendors[id] = new nsString();
switch (id) {
DECLARE_DRIVER_VENDOR_ID(DriverVendorAll, "");
DECLARE_DRIVER_VENDOR_ID(DriverMesaAll, "mesa/all");
DECLARE_DRIVER_VENDOR_ID(DriverMesaLLVMPipe, "mesa/llvmpipe");
DECLARE_DRIVER_VENDOR_ID(DriverMesaSoftPipe, "mesa/softpipe");
DECLARE_DRIVER_VENDOR_ID(DriverMesaSWRast, "mesa/swrast");
DECLARE_DRIVER_VENDOR_ID(DriverMesaUnknown, "mesa/unknown");
// Suppress a warning.
DECLARE_DRIVER_VENDOR_ID(DriverVendorMax, "");
}
return *sDriverVendors[id];
}

98
widget/GfxDriverInfo.h
View File

@ -9,45 +9,47 @@
#include "nsString.h"
// Macros for adding a blocklist item to the static list.
#define APPEND_TO_DRIVER_BLOCKLIST(os, vendor, devices, feature, \
featureStatus, driverComparator, \
driverVersion, ruleId, suggestedVersion) \
sDriverInfo->AppendElement(GfxDriverInfo( \
os, vendor, devices, feature, featureStatus, driverComparator, \
driverVersion, ruleId, suggestedVersion))
#define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, devices, feature, \
featureStatus, driverComparator, \
driverVersion, ruleId) \
sDriverInfo->AppendElement(GfxDriverInfo(os, vendor, devices, feature, \
featureStatus, driverComparator, \
driverVersion, ruleId))
#define APPEND_TO_DRIVER_BLOCKLIST(os, vendor, driverVendor, devices, feature, \
featureStatus, driverComparator, \
driverVersion, ruleId, suggestedVersion) \
sDriverInfo->AppendElement(GfxDriverInfo( \
os, vendor, driverVendor, devices, feature, featureStatus, \
driverComparator, driverVersion, ruleId, suggestedVersion))
#define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, driverVendor, devices, \
feature, featureStatus, driverComparator, \
driverVersion, ruleId) \
sDriverInfo->AppendElement( \
GfxDriverInfo(os, vendor, driverVendor, devices, feature, featureStatus, \
driverComparator, driverVersion, ruleId))
#define APPEND_TO_DRIVER_BLOCKLIST_RANGE( \
os, vendor, devices, feature, featureStatus, driverComparator, \
driverVersion, driverVersionMax, ruleId, suggestedVersion) \
do { \
MOZ_ASSERT(driverComparator == DRIVER_BETWEEN_EXCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE_START); \
GfxDriverInfo info(os, vendor, devices, feature, featureStatus, \
driverComparator, driverVersion, ruleId, \
suggestedVersion); \
info.mDriverVersionMax = driverVersionMax; \
sDriverInfo->AppendElement(info); \
#define APPEND_TO_DRIVER_BLOCKLIST_RANGE( \
os, vendor, driverVendor, devices, feature, featureStatus, \
driverComparator, driverVersion, driverVersionMax, ruleId, \
suggestedVersion) \
do { \
MOZ_ASSERT(driverComparator == DRIVER_BETWEEN_EXCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE_START); \
GfxDriverInfo info(os, vendor, driverVendor, devices, feature, \
featureStatus, driverComparator, driverVersion, ruleId, \
suggestedVersion); \
info.mDriverVersionMax = driverVersionMax; \
sDriverInfo->AppendElement(info); \
} while (false)
#define APPEND_TO_DRIVER_BLOCKLIST_RANGE_GPU2( \
os, vendor, devices, feature, featureStatus, driverComparator, \
driverVersion, driverVersionMax, ruleId, suggestedVersion) \
do { \
MOZ_ASSERT(driverComparator == DRIVER_BETWEEN_EXCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE_START); \
GfxDriverInfo info(os, vendor, devices, feature, featureStatus, \
driverComparator, driverVersion, ruleId, \
suggestedVersion, false, true); \
info.mDriverVersionMax = driverVersionMax; \
sDriverInfo->AppendElement(info); \
#define APPEND_TO_DRIVER_BLOCKLIST_RANGE_GPU2( \
os, vendor, driverVendor, devices, feature, featureStatus, \
driverComparator, driverVersion, driverVersionMax, ruleId, \
suggestedVersion) \
do { \
MOZ_ASSERT(driverComparator == DRIVER_BETWEEN_EXCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE || \
driverComparator == DRIVER_BETWEEN_INCLUSIVE_START); \
GfxDriverInfo info(os, vendor, driverVendor, devices, feature, \
featureStatus, driverComparator, driverVersion, ruleId, \
suggestedVersion, false, true); \
info.mDriverVersionMax = driverVersionMax; \
sDriverInfo->AppendElement(info); \
} while (false)
namespace mozilla {
@ -128,18 +130,23 @@ enum DeviceVendor {
VendorParallels,
VendorQualcomm,
DeviceVendorMax
};
enum DriverVendor {
DriverVendorAll, // There is an assumption that this is the first enum
// Wildcard for all Mesa drivers.
VendorMesaAll,
DriverMesaAll,
// Note that the following list of Mesa drivers is not comprehensive; we pull
// the DRI driver at runtime. These drivers are provided for convenience when
// populating the local blocklist.
VendorMesaLLVMPipe,
VendorMesaSoftPipe,
VendorMesaSWRast,
DriverMesaLLVMPipe,
DriverMesaSoftPipe,
DriverMesaSWRast,
// A generic ID to be provided when we can't determine the DRI driver on Mesa.
VendorMesaUnknown,
DriverMesaUnknown,
DeviceVendorMax
DriverVendorMax
};
/* Array of devices to match, or an empty array for all devices */
@ -148,7 +155,8 @@ typedef nsTArray<nsString> GfxDeviceFamily;
struct GfxDriverInfo {
// If |ownDevices| is true, you are transferring ownership of the devices
// array, and it will be deleted when this GfxDriverInfo is destroyed.
GfxDriverInfo(OperatingSystem os, nsAString& vendor, GfxDeviceFamily* devices,
GfxDriverInfo(OperatingSystem os, const nsAString& vendor,
const nsAString& driverVendor, GfxDeviceFamily* devices,
int32_t feature, int32_t featureStatus, VersionComparisonOp op,
uint64_t driverVersion, const char* ruleId,
const char* suggestedVersion = nullptr, bool ownDevices = false,
@ -162,6 +170,7 @@ struct GfxDriverInfo {
uint32_t mOperatingSystemVersion;
nsString mAdapterVendor;
nsString mDriverVendor;
static GfxDeviceFamily* const allDevices;
GfxDeviceFamily* mDevices;
@ -193,6 +202,9 @@ struct GfxDriverInfo {
static const nsAString& GetDeviceVendor(DeviceVendor id);
static nsAString* sDeviceVendors[DeviceVendorMax];
static const nsAString& GetDriverVendor(DriverVendor id);
static nsAString* sDriverVendors[DriverVendorMax];
nsString mModel, mHardware, mProduct, mManufacturer;
bool mGpu2;

43
widget/GfxInfoBase.cpp
View File

@ -471,6 +471,8 @@ static bool BlacklistEntryToDriverInfo(nsCString& aBlacklistEntry,
aDriverInfo.mOperatingSystemVersion = strtoul(value.get(), nullptr, 10);
} else if (key.EqualsLiteral("vendor")) {
aDriverInfo.mAdapterVendor = dataValue;
} else if (key.EqualsLiteral("driverVendor")) {
aDriverInfo.mDriverVendor = dataValue;
} else if (key.EqualsLiteral("feature")) {
aDriverInfo.mFeature = BlacklistFeatureToGfxFeature(dataValue);
if (aDriverInfo.mFeature < 0) {
@ -679,16 +681,19 @@ int32_t GfxInfoBase::FindBlocklistedDeviceInList(
// Get the adapters once then reuse below
nsAutoString adapterVendorID[2];
nsAutoString adapterDeviceID[2];
nsAutoString adapterDriverVendor[2];
nsAutoString adapterDriverVersionString[2];
bool adapterInfoFailed[2];
adapterInfoFailed[0] =
(NS_FAILED(GetAdapterVendorID(adapterVendorID[0])) ||
NS_FAILED(GetAdapterDeviceID(adapterDeviceID[0])) ||
NS_FAILED(GetAdapterDriverVendor(adapterDriverVendor[0])) ||
NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString[0])));
adapterInfoFailed[1] =
(NS_FAILED(GetAdapterVendorID2(adapterVendorID[1])) ||
NS_FAILED(GetAdapterDeviceID2(adapterDeviceID[1])) ||
NS_FAILED(GetAdapterDriverVendor2(adapterDriverVendor[1])) ||
NS_FAILED(GetAdapterDriverVersion2(adapterDriverVersionString[1])));
// No point in going on if we don't have adapter info
if (adapterInfoFailed[0] && adapterInfoFailed[1]) {
@ -732,6 +737,11 @@ int32_t GfxInfoBase::FindBlocklistedDeviceInList(
continue;
}
if (!DoesDriverVendorMatch(info[i].mDriverVendor,
adapterDriverVendor[infoIndex])) {
continue;
}
if (info[i].mDevices != GfxDriverInfo::allDevices &&
info[i].mDevices->Length()) {
bool deviceMatches = false;
@ -887,6 +897,15 @@ bool GfxInfoBase::DoesVendorMatch(const nsAString& aBlocklistVendor,
nsCaseInsensitiveStringComparator());
}
bool GfxInfoBase::DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aDriverVendor) {
return aBlocklistVendor.Equals(aDriverVendor,
nsCaseInsensitiveStringComparator()) ||
aBlocklistVendor.Equals(
GfxDriverInfo::GetDriverVendor(DriverVendorAll),
nsCaseInsensitiveStringComparator());
}
nsresult GfxInfoBase::GetFeatureStatusImpl(
int32_t aFeature, int32_t* aStatus, nsAString& aSuggestedVersion,
const nsTArray<GfxDriverInfo>& aDriverInfo, nsACString& aFailureId,
@ -1161,6 +1180,30 @@ void GfxInfoBase::RemoveCollector(GfxInfoCollectorBase* collector) {
}
}
nsresult GfxInfoBase::FindMonitors(JSContext* aCx, JS::HandleObject aOutArray) {
// If we have no platform specific implementation for detecting monitors, we
// can just get the screen size from gfxPlatform as the best guess.
if (!gfxPlatform::Initialized()) {
return NS_OK;
}
// If the screen size is empty, we are probably in xpcshell.
gfx::IntSize screenSize = gfxPlatform::GetPlatform()->GetScreenSize();
JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
JS::Rooted<JS::Value> screenWidth(aCx, JS::Int32Value(screenSize.width));
JS_SetProperty(aCx, obj, "screenWidth", screenWidth);
JS::Rooted<JS::Value> screenHeight(aCx, JS::Int32Value(screenSize.height));
JS_SetProperty(aCx, obj, "screenHeight", screenHeight);
JS::Rooted<JS::Value> element(aCx, JS::ObjectValue(*obj));
JS_SetElement(aCx, aOutArray, 0, element);
return NS_OK;
}
NS_IMETHODIMP
GfxInfoBase::GetMonitors(JSContext* aCx, JS::MutableHandleValue aResult) {
JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, 0));

11
widget/GfxInfoBase.h
View File

@ -104,9 +104,7 @@ class GfxInfoBase : public nsIGfxInfo,
// Convenience to get the application version
static const nsCString& GetApplicationVersion();
virtual nsresult FindMonitors(JSContext* cx, JS::HandleObject array) {
return NS_ERROR_NOT_IMPLEMENTED;
}
virtual nsresult FindMonitors(JSContext* cx, JS::HandleObject array);
static void SetFeatureStatus(
const nsTArray<mozilla::dom::GfxInfoFeatureStatus>& aFS);
@ -125,8 +123,11 @@ class GfxInfoBase : public nsIGfxInfo,
virtual void DescribeFeatures(JSContext* aCx, JS::Handle<JSObject*> obj);
virtual bool DoesVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aAdapterVendor);
bool DoesVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aAdapterVendor);
virtual bool DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aDriverVendor);
bool InitFeatureObject(JSContext* aCx, JS::Handle<JSObject*> aContainer,
const char* aName,

66
widget/GfxInfoX11.cpp
View File

@ -221,7 +221,7 @@ void GfxInfo::GetData() {
// GL_VENDOR string.
mIsMesa = glVersion.Find("Mesa") != -1;
// We need to use custom vendor IDs for mesa so we can treat them
// We need to use custom driver vendor IDs for mesa so we can treat them
// differently than the proprietary drivers.
if (mIsMesa) {
mIsAccelerated = !mesaAccelerated.Equals("FALSE");
@ -229,27 +229,34 @@ void GfxInfo::GetData() {
// forcing software rasterization on a DRI-accelerated X server by using
// LIBGL_ALWAYS_SOFTWARE or a similar restriction.
if (strcasestr(glRenderer.get(), "llvmpipe")) {
CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(VendorMesaLLVMPipe),
mVendorId);
CopyUTF16toUTF8(GfxDriverInfo::GetDriverVendor(DriverMesaLLVMPipe),
mDriverVendor);
mIsAccelerated = false;
} else if (strcasestr(glRenderer.get(), "softpipe")) {
CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(VendorMesaSoftPipe),
mVendorId);
CopyUTF16toUTF8(GfxDriverInfo::GetDriverVendor(DriverMesaSoftPipe),
mDriverVendor);
mIsAccelerated = false;
} else if (strcasestr(glRenderer.get(), "software rasterizer") ||
!mIsAccelerated) {
// Fallback to reporting swrast if GLX_MESA_query_renderer tells us
// we're using an unaccelerated context.
CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(VendorMesaSWRast),
mVendorId);
CopyUTF16toUTF8(GfxDriverInfo::GetDriverVendor(DriverMesaSWRast),
mDriverVendor);
mIsAccelerated = false;
} else if (!driDriver.IsEmpty()) {
mVendorId = nsPrintfCString("mesa/%s", driDriver.get());
mDriverVendor = nsPrintfCString("mesa/%s", driDriver.get());
} else {
// Some other mesa configuration where we couldn't get enough info.
NS_WARNING("Failed to detect Mesa driver being used!");
CopyUTF16toUTF8(GfxDriverInfo::GetDeviceVendor(VendorMesaUnknown),
mVendorId);
CopyUTF16toUTF8(GfxDriverInfo::GetDriverVendor(DriverMesaUnknown),
mDriverVendor);
}
if (!mesaVendor.IsEmpty()) {
mVendorId = mesaVendor;
} else {
NS_WARNING(
"Failed to get Mesa vendor ID! GLX_MESA_query_renderer unsupported?");
}
if (!mesaDevice.IsEmpty()) {
@ -287,7 +294,8 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
// to query device IDs backing a GL context for blacklisting.
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Linux,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorMesaAll),
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAll),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverMesaAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(10, 0, 0, 0), "FEATURE_FAILURE_OLD_MESA", "Mesa 10.0");
@ -296,6 +304,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Linux,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(257, 21, 0, 0), "FEATURE_FAILURE_OLD_NVIDIA", "NVIDIA 257.21");
@ -304,6 +313,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Linux,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(13, 15, 100, 1), "FEATURE_FAILURE_OLD_FGLRX", "fglrx 13.15.100.1");
@ -311,19 +321,20 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
////////////////////////////////////
// FEATURE_WEBRENDER
// Mesa baseline (chosen arbitrarily as that which ships with
// Ubuntu 18.04 LTS).
// Intel Mesa baseline, chosen arbitrarily.
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Linux,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorMesaAll),
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBRENDER,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(18, 2, 8, 0), "FEATURE_FAILURE_WEBRENDER_OLD_MESA", "Mesa 18.2.8.0");
V(18, 0, 0, 0), "FEATURE_FAILURE_WEBRENDER_OLD_MESA", "Mesa 18.0.0.0");
// Disable on all NVIDIA devices for now.
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Linux,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBRENDER,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
V(0, 0, 0, 0), "FEATURE_FAILURE_WEBRENDER_NO_LINUX_NVIDIA", "");
@ -332,6 +343,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Linux,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBRENDER,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_COMPARISON_IGNORED,
V(0, 0, 0, 0), "FEATURE_FAILURE_WEBRENDER_NO_LINUX_ATI", "");
@ -339,14 +351,14 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
return *sDriverInfo;
}
bool GfxInfo::DoesVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aAdapterVendor) {
bool GfxInfo::DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aDriverVendor) {
if (mIsMesa &&
aBlocklistVendor.Equals(GfxDriverInfo::GetDeviceVendor(VendorMesaAll),
aBlocklistVendor.Equals(GfxDriverInfo::GetDriverVendor(DriverMesaAll),
nsCaseInsensitiveStringComparator())) {
return true;
}
return GfxInfoBase::DoesVendorMatch(aBlocklistVendor, aAdapterVendor);
return GfxInfoBase::DoesDriverVendorMatch(aBlocklistVendor, aDriverVendor);
}
nsresult GfxInfo::GetFeatureStatusImpl(
@ -445,6 +457,18 @@ GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) {
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
GetData();
CopyASCIItoUTF16(mDriverVendor, aAdapterDriverVendor);
return NS_OK;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) {
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
GetData();
@ -513,9 +537,7 @@ GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active) { return NS_ERROR_FAILURE; }
NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString& aVendorID) {
GetData();
CopyUTF16toUTF8(aVendorID, mVendorId);
mIsAccelerated = !(mVendorId.EqualsLiteral("mesa/llvmpipe") ||
mVendorId.EqualsLiteral("mesa/softpipe") ||
mVendorId.EqualsLiteral("mesa/swrast"));
mIsAccelerated = true;
return NS_OK;
}

7
widget/GfxInfoX11.h
View File

@ -28,6 +28,7 @@ class GfxInfo final : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override;
NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override;
@ -36,6 +37,7 @@ class GfxInfo final : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM2(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion2(
nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override;
@ -61,12 +63,13 @@ class GfxInfo final : public GfxInfoBase {
OperatingSystem* aOS = nullptr) override;
virtual const nsTArray<GfxDriverInfo>& GetGfxDriverInfo() override;
virtual bool DoesVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aAdapterVendor) override;
virtual bool DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
const nsAString& aDriverVendor) override;
private:
nsCString mVendorId;
nsCString mDeviceId;
nsCString mDriverVendor;
nsCString mDriverVersion;
nsCString mAdapterDescription;
nsCString mAdapterRAM;

14
widget/android/GfxInfo.cpp
View File

@ -241,6 +241,19 @@ GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) {
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
EnsureInitialized();
aAdapterDriverVendor.Truncate();
return NS_OK;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) {
EnsureInitialized();
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
EnsureInitialized();
@ -325,6 +338,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Android,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAll),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_OPENGL_LAYERS,
nsIGfxInfo::FEATURE_STATUS_OK, DRIVER_COMPARISON_IGNORED,
GfxDriverInfo::allDriverVersions, "FEATURE_OK_FORCE_OPENGL");

2
widget/android/GfxInfo.h
View File

@ -37,6 +37,7 @@ class GfxInfo : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override;
NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override;
@ -45,6 +46,7 @@ class GfxInfo : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM2(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion2(
nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override;

2
widget/cocoa/GfxInfo.h
View File

@ -30,6 +30,7 @@ class GfxInfo : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override;
NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override;
@ -38,6 +39,7 @@ class GfxInfo : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM2(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion2(
nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override;

18
widget/cocoa/GfxInfo.mm
View File

@ -151,6 +151,17 @@ GfxInfo::GetAdapterDriver(nsAString& aAdapterDriver) {
NS_IMETHODIMP
GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) { return NS_ERROR_FAILURE; }
/* readonly attribute DOMString adapterDriverVendor; */
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
aAdapterDriverVendor.AssignLiteral("");
return NS_OK;
}
/* readonly attribute DOMString adapterDriverVendor2; */
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) { return NS_ERROR_FAILURE; }
/* readonly attribute DOMString adapterDriverVersion; */
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
@ -225,23 +236,26 @@ void GfxInfo::AddCrashReportAnnotations() {
}
// We don't support checking driver versions on Mac.
#define IMPLEMENT_MAC_DRIVER_BLOCKLIST(os, vendor, device, features, blockOn, ruleId) \
APPEND_TO_DRIVER_BLOCKLIST(os, vendor, device, features, blockOn, DRIVER_COMPARISON_IGNORED, \
#define IMPLEMENT_MAC_DRIVER_BLOCKLIST(os, vendor, driverVendor, device, features, blockOn, ruleId) \
APPEND_TO_DRIVER_BLOCKLIST(os, vendor, driverVendor, device, features, blockOn, DRIVER_COMPARISON_IGNORED, \
V(0, 0, 0, 0), ruleId, "")
const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
if (!sDriverInfo->Length()) {
IMPLEMENT_MAC_DRIVER_BLOCKLIST(
OperatingSystem::OSX, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBGL_MSAA,
nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION, "FEATURE_FAILURE_MAC_ATI_NO_MSAA");
IMPLEMENT_MAC_DRIVER_BLOCKLIST(
OperatingSystem::OSX, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(RadeonX1000),
nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
"FEATURE_FAILURE_MAC_RADEONX1000_NO_TEXTURE2D");
IMPLEMENT_MAC_DRIVER_BLOCKLIST(
OperatingSystem::OSX, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Geforce7300GT),
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
"FEATURE_FAILURE_MAC_7300_NO_WEBGL");

3
widget/nsIGfxInfo.idl
View File

@ -58,6 +58,9 @@ interface nsIGfxInfo : nsISupports
readonly attribute AString adapterRAM;
readonly attribute AString adapterRAM2;
readonly attribute AString adapterDriverVendor;
readonly attribute AString adapterDriverVendor2;
readonly attribute AString adapterDriverVersion;
readonly attribute AString adapterDriverVersion2;

74
widget/windows/GfxInfo.cpp
View File

@ -785,6 +785,12 @@ GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) {
return NS_OK;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
aAdapterDriverVendor.Truncate();
return NS_OK;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
aAdapterDriverVersion = mDriverVersion[mActiveGPUIndex];
@ -797,6 +803,12 @@ GfxInfo::GetAdapterDriverDate(nsAString& aAdapterDriverDate) {
return NS_OK;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) {
aAdapterDriverVendor.Truncate();
return NS_OK;
}
NS_IMETHODIMP
GfxInfo::GetAdapterDriverVersion2(nsAString& aAdapterDriverVersion) {
aAdapterDriverVersion = mDriverVersion[1 - mActiveGPUIndex];
@ -1027,6 +1039,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN_OR_EQUAL,
V(8, 15, 11, 8745), "FEATURE_FAILURE_NV_W7_15",
@ -1034,6 +1047,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE_START, V(8, 16, 10, 0000), V(8, 16, 11, 8745),
@ -1043,6 +1057,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE_START, V(8, 17, 10, 0000), V(8, 17, 11, 8745),
@ -1054,12 +1069,14 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(8, 56, 1, 15), "FEATURE_FAILURE_AMD1", "8.56.1.15");
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAMD),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(8, 56, 1, 15), "FEATURE_FAILURE_AMD2", "8.56.1.15");
@ -1068,6 +1085,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_EQUAL,
V(8, 832, 0, 0), "FEATURE_FAILURE_BUG_1099252");
@ -1076,6 +1094,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_EQUAL,
V(8, 783, 2, 2000), "FEATURE_FAILURE_BUG_1118695");
@ -1084,6 +1103,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BETWEEN_INCLUSIVE,
V(15, 200, 0, 0), V(15, 200, 1062, 1004), "FEATURE_FAILURE_BUG_1198815",
@ -1093,6 +1113,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows10,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BETWEEN_INCLUSIVE,
V(15, 200, 0, 0), V(15, 301, 2301, 1002), "FEATURE_FAILURE_BUG_1267970",
@ -1100,6 +1121,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows10,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BETWEEN_INCLUSIVE,
V(16, 100, 0, 0), V(16, 300, 2311, 0), "FEATURE_FAILURE_BUG_1267970",
@ -1111,6 +1133,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows8,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE_START, V(8, 982, 0, 0), V(8, 983, 0, 0),
@ -1118,6 +1141,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows8,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAMD),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE_START, V(8, 982, 0, 0), V(8, 983, 0, 0),
@ -1132,12 +1156,14 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_OPENGL_LAYERS,
nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_OGL_ATI_DIS");
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAMD),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_OPENGL_LAYERS,
nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_OGL_AMD_DIS");
@ -1152,6 +1178,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
#define IMPLEMENT_INTEL_DRIVER_BLOCKLIST(winVer, devFamily, driverVer, ruleId) \
APPEND_TO_DRIVER_BLOCKLIST2( \
winVer, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel), \
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll), \
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(devFamily), \
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, \
DRIVER_LESS_THAN, driverVer, ruleId)
@ -1160,6 +1187,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
ruleId) \
APPEND_TO_DRIVER_BLOCKLIST2( \
winVer, (nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel), \
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll), \
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(devFamily), \
nsIGfxInfo::FEATURE_DIRECT2D, \
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BUILD_ID_LESS_THAN, \
@ -1190,6 +1218,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelGMAX4500HD),
nsIGfxInfo::FEATURE_DIRECT2D, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions,
@ -1221,6 +1250,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelGMAX4500HD),
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_EQUAL, V(8, 15, 10, 1749), "FEATURE_FAILURE_BUG_1074378_1",
@ -1228,6 +1258,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(
IntelHDGraphicsToSandyBridge),
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
@ -1238,6 +1269,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_OPENGL_LAYERS,
nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_INTEL_OGL_DIS");
@ -1249,6 +1281,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelHD3000),
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL, 2321, "FEATURE_FAILURE_BUG_1018278",
@ -1261,6 +1294,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(
IntelHDGraphicsToHaswell),
nsIGfxInfo::FEATURE_DIRECT2D,
@ -1274,6 +1308,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelMobileHDGraphics),
nsIGfxInfo::FEATURE_DIRECT2D,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN_OR_EQUAL,
@ -1285,6 +1320,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows8,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelMobileHDGraphics),
nsIGfxInfo::FEATURE_DIRECT2D,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN_OR_EQUAL,
@ -1296,6 +1332,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(
IntelHDGraphicsToSandyBridge),
nsIGfxInfo::FEATURE_DIRECT2D,
@ -1308,6 +1345,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1116812),
nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
@ -1320,6 +1358,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1207665),
nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
@ -1327,6 +1366,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1207665),
nsIGfxInfo::FEATURE_DIRECT2D, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions,
@ -1335,6 +1375,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows10,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorQualcomm),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_DIRECT2D,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_QUALCOMM");
@ -1345,6 +1386,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows10,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorQualcomm),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN_OR_EQUAL,
V(23, 18, 9310, 0), "FEATURE_FAILURE_BUG_1548410");
@ -1355,6 +1397,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_DIRECT2D,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE_START, V(14, 1, 0, 0), V(14, 2, 0, 0),
@ -1362,6 +1405,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAMD),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_DIRECT2D,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE_START, V(14, 1, 0, 0), V(14, 2, 0, 0),
@ -1373,6 +1417,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(NvidiaBlockD3D9Layers),
nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
@ -1382,6 +1427,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorMicrosoft),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
V(6, 2, 0, 0), "< 6.2.0.0", "FEATURE_FAILURE_REMOTE_FX");
@ -1390,6 +1436,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Nvidia310M),
nsIGfxInfo::FEATURE_DIRECT2D, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions,
@ -1399,6 +1446,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows10,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_EQUAL,
V(15, 200, 1006, 0), "FEATURE_FAILURE_BUG_1139503");
@ -1407,6 +1455,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BETWEEN_INCLUSIVE,
V(8, 861, 0, 0), V(8, 862, 6, 5000), "FEATURE_FAILURE_BUG_1213107_1",
@ -1414,6 +1463,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBGL_ANGLE,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BETWEEN_INCLUSIVE,
V(8, 861, 0, 0), V(8, 862, 6, 5000), "FEATURE_FAILURE_BUG_1213107_2",
@ -1423,6 +1473,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1155608),
nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
@ -1432,6 +1483,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL, 2849,
@ -1440,6 +1492,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Nvidia8800GTS),
nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_EQUAL,
@ -1450,6 +1503,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE_GPU2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1137716),
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
DRIVER_BETWEEN_INCLUSIVE, V(8, 17, 12, 5730), V(8, 17, 12, 6901),
@ -1460,6 +1514,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelGMAX4500HD),
nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
@ -1469,6 +1524,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::WindowsXP,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelGMAX4500HD),
nsIGfxInfo::FEATURE_WEBGL_ANGLE, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions,
@ -1477,6 +1533,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::WindowsXP,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(
IntelHDGraphicsToSandyBridge),
nsIGfxInfo::FEATURE_WEBGL_ANGLE, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
@ -1487,6 +1544,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(IntelGMAX3000),
nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
@ -1498,6 +1556,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_BUG_1403353");
@ -1511,6 +1570,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAMD),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBGL_OPENGL,
nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
V(16, 200, 1010, 1002), "WEBGL_NATIVE_GL_OLD_AMD");
@ -1519,6 +1579,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBGL_OPENGL,
nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_BUILD_ID_LESS_THAN, 4331,
"WEBGL_NATIVE_GL_OLD_INTEL");
@ -1527,6 +1588,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBGL_OPENGL,
nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN, V(10, 18, 13, 6200),
"WEBGL_NATIVE_GL_OLD_NVIDIA");
@ -1538,6 +1600,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAMD),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_DX_INTEROP2,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "DX_INTEROP2_AMD_CRASH");
@ -1549,6 +1612,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(
IntelHDGraphicsToSandyBridge),
nsIGfxInfo::FEATURE_D3D11_KEYED_MUTEX,
@ -1559,6 +1623,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST_RANGE(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_ADVANCED_LAYERS,
nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION, DRIVER_BETWEEN_INCLUSIVE,
V(23, 21, 13, 8569), V(23, 21, 13, 9135), "FEATURE_FAILURE_BUG_1419264",
@ -1568,12 +1633,14 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1447141),
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_EQUAL, V(15, 201, 2201, 0), "FEATURE_FAILURE_BUG_1447141_1");
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorATI),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(Bug1447141),
GfxDriverInfo::allFeatures, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_EQUAL, V(15, 201, 1701, 0), "FEATURE_FAILURE_BUG_1447141_1");
@ -1582,6 +1649,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, GfxDriverInfo::allFeatures,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_EQUAL, V(24, 21, 13, 9731),
"FEATURE_FAILURE_BUG_1457758");
@ -1593,6 +1661,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorIntel),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(
IntelHDGraphicsToSandyBridge),
nsIGfxInfo::FEATURE_DX_NV12, nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION,
@ -1605,6 +1674,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_DX_P010,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions, "FEATURE_UNQUALIFIED_P010_NVIDIA");
@ -1618,6 +1688,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows10,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
(GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(NvidiaBlockWebRender),
nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions,
@ -1627,6 +1698,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows7,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAll),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBRENDER,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions,
@ -1634,6 +1706,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows8,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAll),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBRENDER,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions,
@ -1641,6 +1714,7 @@ const nsTArray<GfxDriverInfo>& GfxInfo::GetGfxDriverInfo() {
APPEND_TO_DRIVER_BLOCKLIST2(
OperatingSystem::Windows8_1,
(nsAString&)GfxDriverInfo::GetDeviceVendor(VendorAll),
(nsAString&)GfxDriverInfo::GetDriverVendor(DriverVendorAll),
GfxDriverInfo::allDevices, nsIGfxInfo::FEATURE_WEBRENDER,
nsIGfxInfo::FEATURE_BLOCKED_DEVICE, DRIVER_LESS_THAN,
GfxDriverInfo::allDriverVersions,

2
widget/windows/GfxInfo.h
View File

@ -31,6 +31,7 @@ class GfxInfo : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override;
NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override;
@ -39,6 +40,7 @@ class GfxInfo : public GfxInfoBase {
NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override;
NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override;
NS_IMETHOD GetAdapterRAM2(nsAString& aAdapterRAM) override;
NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override;
NS_IMETHOD GetAdapterDriverVersion2(
nsAString& aAdapterDriverVersion) override;
NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override;