summaryrefslogtreecommitdiffstats
path: root/widget/GfxDriverInfo.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--widget/GfxDriverInfo.h497
1 files changed, 497 insertions, 0 deletions
diff --git a/widget/GfxDriverInfo.h b/widget/GfxDriverInfo.h
new file mode 100644
index 0000000000..23aa66da4b
--- /dev/null
+++ b/widget/GfxDriverInfo.h
@@ -0,0 +1,497 @@
+/* -*- 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/. */
+
+#ifndef __mozilla_widget_GfxDriverInfo_h__
+#define __mozilla_widget_GfxDriverInfo_h__
+
+#include "nsString.h"
+#include "nsTArray.h"
+
+// Macros for adding a blocklist item to the static list. _EXT variants
+// allow one to specify all available parameters, including those available
+// only on specific platforms (e.g. desktop environment and driver vendor
+// for Linux.)
+
+#define APPEND_TO_DRIVER_BLOCKLIST_EXT( \
+ os, screen, battery, windowProtocol, driverVendor, devices, feature, \
+ featureStatus, driverComparator, driverVersion, ruleId, suggestedVersion) \
+ sDriverInfo->AppendElement(GfxDriverInfo( \
+ os, screen, battery, \
+ (nsAString&)GfxDriverInfo::GetWindowProtocol(windowProtocol), \
+ (nsAString&)GfxDriverInfo::GetDeviceVendor(devices), \
+ (nsAString&)GfxDriverInfo::GetDriverVendor(driverVendor), \
+ (GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(devices), feature, \
+ featureStatus, driverComparator, driverVersion, ruleId, \
+ suggestedVersion))
+
+#define APPEND_TO_DRIVER_BLOCKLIST(os, devices, feature, featureStatus, \
+ driverComparator, driverVersion, ruleId, \
+ suggestedVersion) \
+ APPEND_TO_DRIVER_BLOCKLIST_EXT( \
+ os, ScreenSizeStatus::All, BatteryStatus::All, WindowProtocol::All, \
+ DriverVendor::All, devices, feature, featureStatus, driverComparator, \
+ driverVersion, ruleId, suggestedVersion)
+
+#define APPEND_TO_DRIVER_BLOCKLIST2_EXT( \
+ os, screen, battery, windowProtocol, driverVendor, devices, feature, \
+ featureStatus, driverComparator, driverVersion, ruleId) \
+ sDriverInfo->AppendElement(GfxDriverInfo( \
+ os, screen, battery, \
+ (nsAString&)GfxDriverInfo::GetWindowProtocol(windowProtocol), \
+ (nsAString&)GfxDriverInfo::GetDeviceVendor(devices), \
+ (nsAString&)GfxDriverInfo::GetDriverVendor(driverVendor), \
+ (GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(devices), feature, \
+ featureStatus, driverComparator, driverVersion, ruleId))
+
+#define APPEND_TO_DRIVER_BLOCKLIST2(os, devices, feature, featureStatus, \
+ driverComparator, driverVersion, ruleId) \
+ APPEND_TO_DRIVER_BLOCKLIST2_EXT( \
+ os, ScreenSizeStatus::All, BatteryStatus::All, WindowProtocol::All, \
+ DriverVendor::All, devices, feature, featureStatus, driverComparator, \
+ driverVersion, ruleId)
+
+#define APPEND_TO_DRIVER_BLOCKLIST_RANGE_EXT( \
+ os, screen, battery, windowProtocol, 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, screen, battery, \
+ (nsAString&)GfxDriverInfo::GetWindowProtocol(windowProtocol), \
+ (nsAString&)GfxDriverInfo::GetDeviceVendor(devices), \
+ (nsAString&)GfxDriverInfo::GetDriverVendor(driverVendor), \
+ (GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(devices), feature, \
+ featureStatus, driverComparator, driverVersion, ruleId, \
+ suggestedVersion); \
+ info.mDriverVersionMax = driverVersionMax; \
+ sDriverInfo->AppendElement(info); \
+ } while (false)
+
+#define APPEND_TO_DRIVER_BLOCKLIST_RANGE( \
+ os, devices, feature, featureStatus, driverComparator, driverVersion, \
+ driverVersionMax, ruleId, suggestedVersion) \
+ APPEND_TO_DRIVER_BLOCKLIST_RANGE_EXT( \
+ os, ScreenSizeStatus::All, BatteryStatus::All, WindowProtocol::All, \
+ DriverVendor::All, devices, feature, featureStatus, driverComparator, \
+ driverVersion, driverVersionMax, ruleId, suggestedVersion)
+
+#define APPEND_TO_DRIVER_BLOCKLIST_RANGE_GPU2_EXT( \
+ os, screen, battery, windowProtocol, 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, screen, battery, \
+ (nsAString&)GfxDriverInfo::GetWindowProtocol(windowProtocol), \
+ (nsAString&)GfxDriverInfo::GetDeviceVendor(devices), \
+ (nsAString&)GfxDriverInfo::GetDriverVendor(driverVendor), \
+ (GfxDeviceFamily*)GfxDriverInfo::GetDeviceFamily(devices), feature, \
+ featureStatus, driverComparator, driverVersion, ruleId, \
+ suggestedVersion, false, true); \
+ info.mDriverVersionMax = driverVersionMax; \
+ sDriverInfo->AppendElement(info); \
+ } while (false)
+
+#define APPEND_TO_DRIVER_BLOCKLIST_RANGE_GPU2( \
+ os, devices, feature, featureStatus, driverComparator, driverVersion, \
+ driverVersionMax, ruleId, suggestedVersion) \
+ APPEND_TO_DRIVER_BLOCKLIST_RANGE_GPU2_EXT( \
+ os, ScreenSizeStatus::All, BatteryStatus::All, WindowProtocol::All, \
+ DriverVendor::All, devices, feature, featureStatus, driverComparator, \
+ driverVersion, driverVersionMax, ruleId, suggestedVersion)
+
+namespace mozilla {
+namespace widget {
+
+enum class OperatingSystem : uint8_t {
+ Unknown,
+ Windows,
+ WindowsXP,
+ WindowsServer2003,
+ WindowsVista,
+ Windows7,
+ Windows8,
+ Windows8_1,
+ Windows10,
+ RecentWindows10,
+ NotRecentWindows10,
+ Linux,
+ OSX,
+ OSX10_5,
+ OSX10_6,
+ OSX10_7,
+ OSX10_8,
+ OSX10_9,
+ OSX10_10,
+ OSX10_11,
+ OSX10_12,
+ OSX10_13,
+ OSX10_14,
+ OSX10_15,
+ OSX11_0,
+ Android,
+ Ios
+};
+
+enum VersionComparisonOp {
+ DRIVER_LESS_THAN, // driver < version
+ DRIVER_BUILD_ID_LESS_THAN, // driver build id < version
+ DRIVER_LESS_THAN_OR_EQUAL, // driver <= version
+ DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL, // driver build id <= version
+ DRIVER_GREATER_THAN, // driver > version
+ DRIVER_GREATER_THAN_OR_EQUAL, // driver >= version
+ DRIVER_EQUAL, // driver == version
+ DRIVER_NOT_EQUAL, // driver != version
+ DRIVER_BETWEEN_EXCLUSIVE, // driver > version && driver < versionMax
+ DRIVER_BETWEEN_INCLUSIVE, // driver >= version && driver <= versionMax
+ DRIVER_BETWEEN_INCLUSIVE_START, // driver >= version && driver < versionMax
+ DRIVER_COMPARISON_IGNORED
+};
+
+enum class DeviceFamily : uint8_t {
+ All,
+ IntelAll,
+ NvidiaAll,
+ AtiAll,
+ MicrosoftAll,
+ ParallelsAll,
+ QualcommAll,
+ AppleAll,
+ AmazonAll,
+ IntelGMA500,
+ IntelGMA900,
+ IntelGMA950,
+ IntelGMA3150,
+ IntelGMAX3000,
+ IntelGMAX4500HD,
+ IntelHDGraphicsToIvyBridge,
+ IntelHDGraphicsToSandyBridge,
+ IntelHaswell,
+ IntelSandyBridge,
+ IntelGen7Baytrail,
+ IntelSkylake,
+ IntelHD520,
+ IntelMobileHDGraphics,
+ NvidiaBlockD3D9Layers,
+ RadeonX1000,
+ RadeonCaicos,
+ RadeonBlockZeroVideoCopy,
+ Geforce7300GT,
+ Nvidia310M,
+ Nvidia8800GTS,
+ Bug1137716,
+ Bug1116812,
+ Bug1155608,
+ Bug1207665,
+ Bug1447141,
+ AmdR600,
+ IntelWebRenderBlocked,
+ NvidiaWebRenderBlocked,
+
+ Max
+};
+
+enum class DeviceVendor : uint8_t {
+ All, // There is an assumption that this is the first enum
+ Intel,
+ NVIDIA,
+ ATI,
+ Microsoft,
+ Parallels,
+ VMWare,
+ VirtualBox,
+ Qualcomm,
+ MicrosoftBasic,
+ MicrosoftHyperV,
+ Apple,
+ Amazon,
+
+ Max
+};
+
+enum DriverVendor : uint8_t {
+ All, // There is an assumption that this is the first enum
+ // Wildcard for all Mesa drivers.
+ MesaAll,
+ // 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.
+ MesaLLVMPipe,
+ MesaSoftPipe,
+ MesaSWRast,
+ MesaSWUnknown,
+ // AMD
+ MesaR600,
+ // Nouveau: Open-source nvidia
+ MesaNouveau,
+ // A generic ID to be provided when we can't determine the DRI driver on Mesa.
+ MesaUnknown,
+ // Wildcard for all non-Mesa drivers.
+ NonMesaAll,
+ // Wildcard for all hardware Mesa drivers.
+ HardwareMesaAll,
+ // Wildcard for all software Mesa drivers.
+ SoftwareMesaAll,
+ // Wildcard for all non-Intel/NVIDIA/ATI Mesa drivers.
+ MesaNonIntelNvidiaAtiAll,
+ // Running in VM.
+ MesaVM,
+
+ Max
+};
+
+enum class WindowProtocol : uint8_t {
+ All, // There is an assumption that this is the first enum
+ X11,
+ XWayland,
+ Wayland,
+ WaylandDRM,
+ // Wildcard for all Wayland variants, excluding XWayland.
+ WaylandAll,
+ // Wildcard for all X11 variants, including XWayland.
+ X11All,
+ Max
+};
+
+enum class BatteryStatus : uint8_t { All, Present, None };
+
+enum class ScreenSizeStatus : uint8_t {
+ All,
+ Small, // <= 1900x1200
+ SmallAndMedium, // <= 3440x1440
+ Medium, // <= 3440x1440 && > 1900x1200
+ MediumAndLarge, // >1900x1200
+ Large // > 3440x1440
+};
+
+/* Array of devices to match, or an empty array for all devices */
+class GfxDeviceFamily final {
+ public:
+ GfxDeviceFamily() = default;
+
+ void Append(const nsAString& aDeviceId);
+ void AppendRange(int32_t aBeginDeviceId, int32_t aEndDeviceId);
+
+ bool IsEmpty() const { return mIds.IsEmpty() && mRanges.IsEmpty(); }
+
+ nsresult Contains(nsAString& aDeviceId) const;
+
+ private:
+ struct DeviceRange {
+ int32_t mBegin;
+ int32_t mEnd;
+ };
+
+ CopyableTArray<nsString> mIds;
+ CopyableTArray<DeviceRange> mRanges;
+};
+
+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, ScreenSizeStatus aScreen,
+ BatteryStatus aBattery, const nsAString& windowProtocol,
+ 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,
+ bool gpu2 = false);
+
+ GfxDriverInfo();
+ GfxDriverInfo(const GfxDriverInfo&);
+ ~GfxDriverInfo();
+
+ OperatingSystem mOperatingSystem;
+ uint32_t mOperatingSystemVersion;
+ ScreenSizeStatus mScreen;
+ BatteryStatus mBattery;
+ nsString mWindowProtocol;
+
+ nsString mAdapterVendor;
+ nsString mDriverVendor;
+
+ const GfxDeviceFamily* mDevices;
+
+ // Whether the mDevices array should be deleted when this structure is
+ // deallocated. False by default.
+ bool mDeleteDevices;
+
+ /* A feature from nsIGfxInfo, or all features */
+ int32_t mFeature;
+ static int32_t allFeatures;
+
+ /* A feature status from nsIGfxInfo */
+ int32_t mFeatureStatus;
+
+ VersionComparisonOp mComparisonOp;
+
+ /* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */
+ uint64_t mDriverVersion;
+ uint64_t mDriverVersionMax;
+ static uint64_t allDriverVersions;
+
+ const char* mSuggestedVersion;
+ nsCString mRuleId;
+
+ static const GfxDeviceFamily* GetDeviceFamily(DeviceFamily id);
+ static GfxDeviceFamily*
+ sDeviceFamilies[static_cast<size_t>(DeviceFamily::Max)];
+
+ static const nsAString& GetWindowProtocol(WindowProtocol id);
+ static nsString* sWindowProtocol[static_cast<size_t>(WindowProtocol::Max)];
+
+ static const nsAString& GetDeviceVendor(DeviceVendor id);
+ static const nsAString& GetDeviceVendor(DeviceFamily id);
+ static nsString* sDeviceVendors[static_cast<size_t>(DeviceVendor::Max)];
+
+ static const nsAString& GetDriverVendor(DriverVendor id);
+ static nsString* sDriverVendors[static_cast<size_t>(DriverVendor::Max)];
+
+ nsString mModel, mHardware, mProduct, mManufacturer;
+
+ bool mGpu2;
+};
+
+inline uint64_t DriverVersion(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
+ return (uint64_t(a) << 48) | (uint64_t(b) << 32) | (uint64_t(c) << 16) |
+ uint64_t(d);
+}
+
+inline uint64_t V(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
+#ifdef XP_WIN
+ // We make sure every driver number is padded by 0s, this will allow us the
+ // easiest 'compare as if decimals' approach. See ParseDriverVersion for a
+ // more extensive explanation of this approach.
+ while (b > 0 && b < 1000) {
+ b *= 10;
+ }
+ while (c > 0 && c < 1000) {
+ c *= 10;
+ }
+ while (d > 0 && d < 1000) {
+ d *= 10;
+ }
+#endif
+ return DriverVersion(a, b, c, d);
+}
+
+// All destination string storage needs to have at least 5 bytes available.
+inline bool SplitDriverVersion(const char* aSource, char* aAStr, char* aBStr,
+ char* aCStr, char* aDStr) {
+ // sscanf doesn't do what we want here to we parse this manually.
+ int len = strlen(aSource);
+
+ // This "4" is hardcoded in a few places, including once as a 3.
+ char* dest[4] = {aAStr, aBStr, aCStr, aDStr};
+ unsigned destIdx = 0;
+ unsigned destPos = 0;
+
+ for (int i = 0; i < len; i++) {
+ if (destIdx >= 4) {
+ // Invalid format found. Ensure we don't access dest beyond bounds.
+ return false;
+ }
+
+ if (aSource[i] == '.') {
+ MOZ_ASSERT(destIdx < 4 && destPos <= 4);
+ dest[destIdx++][destPos] = 0;
+ destPos = 0;
+ continue;
+ }
+
+ if (destPos > 3) {
+ // Ignore more than 4 chars. Ensure we never access dest[destIdx]
+ // beyond its bounds.
+ continue;
+ }
+
+ MOZ_ASSERT(destIdx < 4 && destPos < 4);
+ dest[destIdx][destPos++] = aSource[i];
+ }
+
+ // Take care of the trailing period
+ if (destIdx >= 4) {
+ return false;
+ }
+
+ // Add last terminator.
+ MOZ_ASSERT(destIdx < 4 && destPos <= 4);
+ dest[destIdx][destPos] = 0;
+ for (int unusedDestIdx = destIdx + 1; unusedDestIdx < 4; unusedDestIdx++) {
+ dest[unusedDestIdx][0] = 0;
+ }
+
+ if (destIdx != 3) {
+ return false;
+ }
+ return true;
+}
+
+// This allows us to pad driver version 'substrings' with 0s, this
+// effectively allows us to treat the version numbers as 'decimals'. This is
+// a little strange but this method seems to do the right thing for all
+// different vendor's driver strings. i.e. .98 will become 9800, which is
+// larger than .978 which would become 9780.
+inline void PadDriverDecimal(char* aString) {
+ for (int i = 0; i < 4; i++) {
+ if (!aString[i]) {
+ for (int c = i; c < 4; c++) {
+ aString[c] = '0';
+ }
+ break;
+ }
+ }
+ aString[4] = 0;
+}
+
+inline bool ParseDriverVersion(const nsAString& aVersion,
+ uint64_t* aNumericVersion) {
+ *aNumericVersion = 0;
+
+#ifndef ANDROID
+ int a, b, c, d;
+ char aStr[8], bStr[8], cStr[8], dStr[8];
+ /* honestly, why do I even bother */
+ if (!SplitDriverVersion(NS_LossyConvertUTF16toASCII(aVersion).get(), aStr,
+ bStr, cStr, dStr))
+ return false;
+
+# ifdef XP_WIN
+ PadDriverDecimal(bStr);
+ PadDriverDecimal(cStr);
+ PadDriverDecimal(dStr);
+# endif
+
+ a = atoi(aStr);
+ b = atoi(bStr);
+ c = atoi(cStr);
+ d = atoi(dStr);
+
+ if (a < 0 || a > 0xffff) return false;
+ if (b < 0 || b > 0xffff) return false;
+ if (c < 0 || c > 0xffff) return false;
+ if (d < 0 || d > 0xffff) return false;
+
+ *aNumericVersion = DriverVersion(a, b, c, d);
+#else
+ // Can't use aVersion.ToInteger() because that's not compiled into our code
+ // unless we have XPCOM_GLUE_AVOID_NSPR disabled.
+ *aNumericVersion = atoi(NS_LossyConvertUTF16toASCII(aVersion).get());
+#endif
+ MOZ_ASSERT(*aNumericVersion != GfxDriverInfo::allDriverVersions);
+ return true;
+}
+
+} // namespace widget
+} // namespace mozilla
+
+#endif /*__mozilla_widget_GfxDriverInfo_h__ */