The Tor Browser: comparison widget/xpwidgets/GfxDriverInfo.h

--1:000000000000
+:e6bc7e6a7ec1
+/* -*- 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 "mozilla/ArrayUtils.h" // ArrayLength
+#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, suggestedVersion) \
+mDriverInfo->AppendElement(GfxDriverInfo(os, vendor, devices, feature, featureStatus, driverComparator, driverVersion, suggestedVersion))
+#define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, devices, feature, featureStatus, driverComparator, driverVersion) \
+mDriverInfo->AppendElement(GfxDriverInfo(os, vendor, devices, feature, featureStatus, driverComparator, driverVersion))
+#define APPEND_TO_DRIVER_BLOCKLIST_RANGE(os, vendor, devices, feature, featureStatus, driverComparator, driverVersion, driverVersionMax, 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, suggestedVersion); \
+info.mDriverVersionMax = driverVersionMax; \
+mDriverInfo->AppendElement(info); \
+} while (false)
+namespace mozilla {
+namespace widget {
+enum OperatingSystem {
+DRIVER_OS_UNKNOWN = 0,
+DRIVER_OS_WINDOWS_XP,
+DRIVER_OS_WINDOWS_SERVER_2003,
+DRIVER_OS_WINDOWS_VISTA,
+DRIVER_OS_WINDOWS_7,
+DRIVER_OS_WINDOWS_8,
+DRIVER_OS_WINDOWS_8_1,
+DRIVER_OS_LINUX,
+DRIVER_OS_OS_X_10_5,
+DRIVER_OS_OS_X_10_6,
+DRIVER_OS_OS_X_10_7,
+DRIVER_OS_OS_X_10_8,
+DRIVER_OS_ANDROID,
+DRIVER_OS_ALL
+};
+enum VersionComparisonOp {
+DRIVER_LESS_THAN,             // driver <  version
+DRIVER_LESS_THAN_OR_EQUAL,    // driver <= 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 DeviceFamily {
+IntelGMA500,
+IntelGMA900,
+IntelGMA950,
+IntelGMA3150,
+IntelGMAX3000,
+IntelGMAX4500HD,
+IntelMobileHDGraphics,
+NvidiaBlockD3D9Layers,
+RadeonX1000,
+Geforce7300GT,
+DeviceFamilyMax
+};
+enum DeviceVendor {
+VendorAll,
+VendorIntel,
+VendorNVIDIA,
+VendorAMD,
+VendorATI,
+VendorMicrosoft,
+DeviceVendorMax
+};
+/* Array of devices to match, or an empty array for all devices */
+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,
+int32_t feature, int32_t featureStatus, VersionComparisonOp op,
+uint64_t driverVersion, const char *suggestedVersion = nullptr,
+bool ownDevices = false);
+GfxDriverInfo();
+GfxDriverInfo(const GfxDriverInfo&);
+~GfxDriverInfo();
+OperatingSystem mOperatingSystem;
+uint32_t mOperatingSystemVersion;
+nsString mAdapterVendor;
+static GfxDeviceFamily* const allDevices;
+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;
+static const GfxDeviceFamily* GetDeviceFamily(DeviceFamily id);
+static GfxDeviceFamily* mDeviceFamilies[DeviceFamilyMax];
+static const nsAString& GetDeviceVendor(DeviceVendor id);
+static nsAString* mDeviceVendors[DeviceVendorMax];
+nsString mModel, mHardware, mProduct, mManufacturer;
+};
+#define GFX_DRIVER_VERSION(a,b,c,d) \
+((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)
+{
+// 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;
+}
+return GFX_DRIVER_VERSION(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);
+char *dest[4] = { aAStr, aBStr, aCStr, aDStr };
+unsigned destIdx = 0;
+unsigned destPos = 0;
+for (int i = 0; i < len; i++) {
+if (destIdx > ArrayLength(dest)) {
+// Invalid format found. Ensure we don't access dest beyond bounds.
+return false;
+}
+if (aSource[i] == '.') {
+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;
+}
+dest[destIdx][destPos++] = aSource[i];
+}
+// Add last terminator.
+dest[destIdx][destPos] = 0;
+if (destIdx != ArrayLength(dest) - 1) {
+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;
+#if defined(XP_WIN)
+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;
+PadDriverDecimal(bStr);
+PadDriverDecimal(cStr);
+PadDriverDecimal(dStr);
+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 = GFX_DRIVER_VERSION(a, b, c, d);
+return true;
+#elif defined(ANDROID)
+// 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());
+return true;
+#else
+return false;
+#endif
+}
+}
+}
+#endif /*__mozilla_widget_GfxDriverInfo_h__ */

The Tor Browser / file comparison

comparison: widget/xpwidgets/GfxDriverInfo.h

widget/xpwidgets/GfxDriverInfo.h