Bug 1460699: Use an 's' rather than 'm' prefix for GfxInfo static variables. r=milan
authorDavid Major <dmajor@mozilla.com>
Mon, 14 May 2018 11:16:50 -0400
changeset 472403 5d368658145949915eaaa095275cc20a6fa76748
parent 472402 5166f4f5af706b3c37982ac1e94498d979b8198d
child 472404 9eb850fd168812a2a8f427814335fdd93ab64ae5
push id9374
push userjlund@mozilla.com
push dateMon, 18 Jun 2018 21:43:20 +0000
treeherdermozilla-beta@160e085dfb0b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmilan
bugs1460699
milestone62.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1460699: Use an 's' rather than 'm' prefix for GfxInfo static variables. r=milan
widget/GfxDriverInfo.cpp
widget/GfxDriverInfo.h
widget/GfxInfoBase.cpp
widget/GfxInfoBase.h
widget/GfxInfoX11.cpp
widget/android/GfxInfo.cpp
widget/cocoa/GfxInfo.mm
widget/uikit/GfxInfo.cpp
widget/windows/GfxInfo.cpp
--- a/widget/GfxDriverInfo.cpp
+++ b/widget/GfxDriverInfo.cpp
@@ -9,18 +9,18 @@
 #include "nsTArray.h"
 
 using namespace mozilla::widget;
 
 int32_t GfxDriverInfo::allFeatures = 0;
 uint64_t GfxDriverInfo::allDriverVersions = ~(uint64_t(0));
 GfxDeviceFamily* const GfxDriverInfo::allDevices = nullptr;
 
-GfxDeviceFamily* GfxDriverInfo::mDeviceFamilies[DeviceFamilyMax];
-nsAString* GfxDriverInfo::mDeviceVendors[DeviceVendorMax];
+GfxDeviceFamily* GfxDriverInfo::sDeviceFamilies[DeviceFamilyMax];
+nsAString* GfxDriverInfo::sDeviceVendors[DeviceVendorMax];
 
 GfxDriverInfo::GfxDriverInfo()
   : mOperatingSystem(OperatingSystem::Unknown),
     mOperatingSystemVersion(0),
     mAdapterVendor(GfxDriverInfo::GetDeviceVendor(VendorAll)),
     mDevices(allDevices),
     mDeleteDevices(false),
     mFeature(allFeatures),
@@ -94,21 +94,21 @@ GfxDriverInfo::~GfxDriverInfo()
 
 const GfxDeviceFamily* GfxDriverInfo::GetDeviceFamily(DeviceFamily id)
 {
   // The code here is too sensitive to fall through to the default case if the
   // code is invalid.
   NS_ASSERTION(id >= 0 && id < DeviceFamilyMax, "DeviceFamily id is out of range");
 
   // If it already exists, we must have processed it once, so return it now.
-  if (mDeviceFamilies[id])
-    return mDeviceFamilies[id];
+  if (sDeviceFamilies[id])
+    return sDeviceFamilies[id];
 
-  mDeviceFamilies[id] = new GfxDeviceFamily;
-  GfxDeviceFamily* deviceFamily = mDeviceFamilies[id];
+  sDeviceFamilies[id] = new GfxDeviceFamily;
+  GfxDeviceFamily* deviceFamily = sDeviceFamilies[id];
 
   switch (id) {
     case IntelGMA500:
       APPEND_DEVICE(0x8108); /* IntelGMA500_1 */
       APPEND_DEVICE(0x8109); /* IntelGMA500_2 */
       break;
     case IntelGMA900:
       APPEND_DEVICE(0x2582); /* IntelGMA900_1 */
@@ -327,37 +327,37 @@ const GfxDeviceFamily* GfxDriverInfo::Ge
   }
 
   return deviceFamily;
 }
 
 // Macro for assigning a device vendor id to a string.
 #define DECLARE_VENDOR_ID(name, deviceId) \
   case name: \
-    mDeviceVendors[id]->AssignLiteral(deviceId); \
+    sDeviceVendors[id]->AssignLiteral(deviceId); \
     break;
 
 const nsAString& GfxDriverInfo::GetDeviceVendor(DeviceVendor id)
 {
   NS_ASSERTION(id >= 0 && id < DeviceVendorMax, "DeviceVendor id is out of range");
 
-  if (mDeviceVendors[id])
-    return *mDeviceVendors[id];
+  if (sDeviceVendors[id])
+    return *sDeviceVendors[id];
 
-  mDeviceVendors[id] = new nsString();
+  sDeviceVendors[id] = new nsString();
 
   switch (id) {
     DECLARE_VENDOR_ID(VendorAll, "");
     DECLARE_VENDOR_ID(VendorIntel, "0x8086");
     DECLARE_VENDOR_ID(VendorNVIDIA, "0x10de");
     DECLARE_VENDOR_ID(VendorAMD, "0x1022");
     DECLARE_VENDOR_ID(VendorATI, "0x1002");
     DECLARE_VENDOR_ID(VendorMicrosoft, "0x1414");
     DECLARE_VENDOR_ID(VendorParallels, "0x1ab8");
     // 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");
     // Suppress a warning.
     DECLARE_VENDOR_ID(DeviceVendorMax, "");
   }
 
-  return *mDeviceVendors[id];
+  return *sDeviceVendors[id];
 }
--- a/widget/GfxDriverInfo.h
+++ b/widget/GfxDriverInfo.h
@@ -5,38 +5,38 @@
 
 #ifndef __mozilla_widget_GfxDriverInfo_h__
 #define __mozilla_widget_GfxDriverInfo_h__
 
 #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) \
-    mDriverInfo->AppendElement(GfxDriverInfo(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) \
-    mDriverInfo->AppendElement(GfxDriverInfo(os, vendor, devices, feature, featureStatus, driverComparator, driverVersion, ruleId))
+    sDriverInfo->AppendElement(GfxDriverInfo(os, vendor, 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; \
-      mDriverInfo->AppendElement(info); \
+      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; \
-      mDriverInfo->AppendElement(info); \
+      sDriverInfo->AppendElement(info); \
     } while (false)
 
 
 namespace mozilla {
 namespace widget {
 
 enum class OperatingSystem {
   Unknown,
@@ -156,20 +156,20 @@ struct GfxDriverInfo
   uint64_t mDriverVersion;
   uint64_t mDriverVersionMax;
   static uint64_t allDriverVersions;
 
   const char *mSuggestedVersion;
   nsCString mRuleId;
 
   static const GfxDeviceFamily* GetDeviceFamily(DeviceFamily id);
-  static GfxDeviceFamily* mDeviceFamilies[DeviceFamilyMax];
+  static GfxDeviceFamily* sDeviceFamilies[DeviceFamilyMax];
 
   static const nsAString& GetDeviceVendor(DeviceVendor id);
-  static nsAString* mDeviceVendors[DeviceVendorMax];
+  static nsAString* sDeviceVendors[DeviceVendorMax];
 
   nsString mModel, mHardware, mProduct, mManufacturer;
 
   bool mGpu2;
 };
 
 #define GFX_DRIVER_VERSION(a,b,c,d) \
   ((uint64_t(a)<<48) | (uint64_t(b)<<32) | (uint64_t(c)<<16) | uint64_t(d))
--- a/widget/GfxInfoBase.cpp
+++ b/widget/GfxInfoBase.cpp
@@ -34,66 +34,66 @@
 #include "gfxPlatform.h"
 #include "gfxConfig.h"
 #include "DriverCrashGuard.h"
 
 using namespace mozilla::widget;
 using namespace mozilla;
 using mozilla::MutexAutoLock;
 
-nsTArray<GfxDriverInfo>* GfxInfoBase::mDriverInfo;
-nsTArray<dom::GfxInfoFeatureStatus>* GfxInfoBase::mFeatureStatus;
-bool GfxInfoBase::mDriverInfoObserverInitialized;
-bool GfxInfoBase::mShutdownOccurred;
+nsTArray<GfxDriverInfo>* GfxInfoBase::sDriverInfo;
+nsTArray<dom::GfxInfoFeatureStatus>* GfxInfoBase::sFeatureStatus;
+bool GfxInfoBase::sDriverInfoObserverInitialized;
+bool GfxInfoBase::sShutdownOccurred;
 
 // 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;
+    delete GfxInfoBase::sDriverInfo;
+    GfxInfoBase::sDriverInfo = nullptr;
 
-    delete GfxInfoBase::mFeatureStatus;
-    GfxInfoBase::mFeatureStatus = nullptr;
+    delete GfxInfoBase::sFeatureStatus;
+    GfxInfoBase::sFeatureStatus = nullptr;
 
     for (uint32_t i = 0; i < DeviceFamilyMax; i++) {
-      delete GfxDriverInfo::mDeviceFamilies[i];
-      GfxDriverInfo::mDeviceFamilies[i] = nullptr;
+      delete GfxDriverInfo::sDeviceFamilies[i];
+      GfxDriverInfo::sDeviceFamilies[i] = nullptr;
     }
 
     for (uint32_t i = 0; i < DeviceVendorMax; i++) {
-      delete GfxDriverInfo::mDeviceVendors[i];
-      GfxDriverInfo::mDeviceVendors[i] = nullptr;
+      delete GfxDriverInfo::sDeviceVendors[i];
+      GfxDriverInfo::sDeviceVendors[i] = nullptr;
     }
 
-    GfxInfoBase::mShutdownOccurred = true;
+    GfxInfoBase::sShutdownOccurred = true;
 
     return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(ShutdownObserver, nsIObserver)
 
 void InitGfxDriverInfoShutdownObserver()
 {
-  if (GfxInfoBase::mDriverInfoObserverInitialized)
+  if (GfxInfoBase::sDriverInfoObserverInitialized)
     return;
 
-  GfxInfoBase::mDriverInfoObserverInitialized = true;
+  GfxInfoBase::sDriverInfoObserverInitialized = true;
 
   nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
   if (!observerService) {
     NS_WARNING("Could not get observer service!");
     return;
   }
 
   ShutdownObserver *obs = new ShutdownObserver();
@@ -629,19 +629,19 @@ GfxInfoBase::GetFeatureStatus(int32_t aF
   }
 
   if (GetPrefValueForFeature(aFeature, *aStatus, aFailureId)) {
     return NS_OK;
   }
 
   if (XRE_IsContentProcess()) {
     // Use the cached data received from the parent process.
-    MOZ_ASSERT(mFeatureStatus);
+    MOZ_ASSERT(sFeatureStatus);
     bool success = false;
-    for (const auto& fs : *mFeatureStatus) {
+    for (const auto& fs : *sFeatureStatus) {
       if (fs.feature() == aFeature) {
         aFailureId = fs.failureId();
         *aStatus = fs.status();
         success = true;
         break;
       }
     }
     return success ? NS_OK : NS_ERROR_FAILURE;
@@ -884,18 +884,18 @@ GfxInfoBase::FindBlocklistedDeviceInList
 #endif
 
   return status;
 }
 
 void
 GfxInfoBase::SetFeatureStatus(const nsTArray<dom::GfxInfoFeatureStatus>& aFS)
 {
-  MOZ_ASSERT(!mFeatureStatus);
-  mFeatureStatus = new nsTArray<dom::GfxInfoFeatureStatus>(aFS);
+  MOZ_ASSERT(!sFeatureStatus);
+  sFeatureStatus = new nsTArray<dom::GfxInfoFeatureStatus>(aFS);
 }
 
 nsresult
 GfxInfoBase::GetFeatureStatusImpl(int32_t aFeature,
                                   int32_t* aStatus,
                                   nsAString& aSuggestedVersion,
                                   const nsTArray<GfxDriverInfo>& aDriverInfo,
                                   nsACString& aFailureId,
@@ -907,17 +907,17 @@ GfxInfoBase::GetFeatureStatusImpl(int32_
   }
 
   if (*aStatus != nsIGfxInfo::FEATURE_STATUS_UNKNOWN) {
     // Terminate now with the status determined by the derived type (OS-specific
     // code).
     return NS_OK;
   }
 
-  if (mShutdownOccurred) {
+  if (sShutdownOccurred) {
     // This is futile; we've already commenced shutdown and our blocklists have
     // been deleted. We may want to look into resurrecting the blocklist instead
     // but for now, just don't even go there.
     return NS_OK;
   }
 
   // If an operating system was provided by the derived GetFeatureStatusImpl,
   // grab it here. Otherwise, the OS is unknown.
@@ -938,18 +938,18 @@ GfxInfoBase::GetFeatureStatusImpl(int32_
   // 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>();
+    if (!sDriverInfo) {
+      sDriverInfo = 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 {
--- a/widget/GfxInfoBase.h
+++ b/widget/GfxInfoBase.h
@@ -76,20 +76,20 @@ public:
   virtual nsresult Init();
   
   // only useful on X11
   NS_IMETHOD_(void) GetData() override { }
 
   static void AddCollector(GfxInfoCollectorBase* collector);
   static void RemoveCollector(GfxInfoCollectorBase* collector);
 
-  static nsTArray<GfxDriverInfo>* mDriverInfo;
-  static nsTArray<mozilla::dom::GfxInfoFeatureStatus>* mFeatureStatus;
-  static bool mDriverInfoObserverInitialized;
-  static bool mShutdownOccurred;
+  static nsTArray<GfxDriverInfo>* sDriverInfo;
+  static nsTArray<mozilla::dom::GfxInfoFeatureStatus>* sFeatureStatus;
+  static bool sDriverInfoObserverInitialized;
+  static bool sShutdownOccurred;
 
   virtual nsString Model() { return EmptyString(); }
   virtual nsString Hardware() { return EmptyString(); }
   virtual nsString Product() { return EmptyString(); }
   virtual nsString Manufacturer() { return EmptyString(); }
   virtual uint32_t OperatingSystemVersion() { return 0; }
 
   // Convenience to get the application version
--- a/widget/GfxInfoX11.cpp
+++ b/widget/GfxInfoX11.cpp
@@ -255,20 +255,20 @@ static inline uint64_t version(uint32_t 
 {
     return (uint64_t(major) << 32) + (uint64_t(minor) << 16) + uint64_t(revision);
 }
 
 const nsTArray<GfxDriverInfo>&
 GfxInfo::GetGfxDriverInfo()
 {
   // Nothing here yet.
-  //if (!mDriverInfo->Length()) {
+  //if (!sDriverInfo->Length()) {
   //
   //}
-  return *mDriverInfo;
+  return *sDriverInfo;
 }
 
 nsresult
 GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
                               int32_t *aStatus,
                               nsAString & aSuggestedDriverVersion,
                               const nsTArray<GfxDriverInfo>& aDriverInfo,
                               nsACString& aFailureId,
@@ -277,17 +277,17 @@ GfxInfo::GetFeatureStatusImpl(int32_t aF
 {
   NS_ENSURE_ARG_POINTER(aStatus);
   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
   aSuggestedDriverVersion.SetIsVoid(true);
   OperatingSystem os = OperatingSystem::Linux;
   if (aOS)
     *aOS = os;
 
-  if (mShutdownOccurred) {
+  if (sShutdownOccurred) {
     return NS_OK;
   }
 
   GetData();
 
   if (mGLMajorVersion == 1) {
     // We're on OpenGL 1. In most cases that indicates really old hardware.
     // We better block them, rather than rely on them to fail gracefully, because they don't!
--- a/widget/android/GfxInfo.cpp
+++ b/widget/android/GfxInfo.cpp
@@ -361,25 +361,25 @@ GfxInfo::AddCrashReportAnnotations()
   note.AppendPrintf("AdapterDescription: '%s'\n", mAdapterDescription.get());
 
   CrashReporter::AppendAppNotesToCrashReport(note);
 }
 
 const nsTArray<GfxDriverInfo>&
 GfxInfo::GetGfxDriverInfo()
 {
-  if (mDriverInfo->IsEmpty()) {
+  if (sDriverInfo->IsEmpty()) {
     APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Android,
       (nsAString&) GfxDriverInfo::GetDeviceVendor(VendorAll), GfxDriverInfo::allDevices,
       nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_STATUS_OK,
       DRIVER_COMPARISON_IGNORED, GfxDriverInfo::allDriverVersions,
       "FEATURE_OK_FORCE_OPENGL" );
   }
 
-  return *mDriverInfo;
+  return *sDriverInfo;
 }
 
 nsresult
 GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
                               int32_t *aStatus,
                               nsAString &aSuggestedDriverVersion,
                               const nsTArray<GfxDriverInfo>& aDriverInfo,
                               nsACString &aFailureId,
@@ -387,17 +387,17 @@ GfxInfo::GetFeatureStatusImpl(int32_t aF
 {
   NS_ENSURE_ARG_POINTER(aStatus);
   aSuggestedDriverVersion.SetIsVoid(true);
   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
   OperatingSystem os = mOS;
   if (aOS)
     *aOS = os;
 
-  if (mShutdownOccurred) {
+  if (sShutdownOccurred) {
     return NS_OK;
   }
 
   // OpenGL layers are never blacklisted on Android.
   // This early return is so we avoid potentially slow
   // GLStrings initialization on startup when we initialize GL layers.
   if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS) {
     *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
--- a/widget/cocoa/GfxInfo.mm
+++ b/widget/cocoa/GfxInfo.mm
@@ -304,28 +304,28 @@ GfxInfo::AddCrashReportAnnotations()
 #define IMPLEMENT_MAC_DRIVER_BLOCKLIST(os, vendor, device, features, blockOn, ruleId) \
   APPEND_TO_DRIVER_BLOCKLIST(os, vendor, device, features, blockOn,           \
                              DRIVER_COMPARISON_IGNORED, V(0,0,0,0), ruleId, "")
 
 
 const nsTArray<GfxDriverInfo>&
 GfxInfo::GetGfxDriverInfo()
 {
-  if (!mDriverInfo->Length()) {
+  if (!sDriverInfo->Length()) {
     IMPLEMENT_MAC_DRIVER_BLOCKLIST(OperatingSystem::OSX,
       (nsAString&) GfxDriverInfo::GetDeviceVendor(VendorATI), 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), (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), (GfxDeviceFamily*) GfxDriverInfo::GetDeviceFamily(Geforce7300GT),
       nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_BLOCKED_DEVICE, "FEATURE_FAILURE_MAC_7300_NO_WEBGL");
   }
-  return *mDriverInfo;
+  return *sDriverInfo;
 }
 
 nsresult
 GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
                               int32_t* aStatus,
                               nsAString& aSuggestedDriverVersion,
                               const nsTArray<GfxDriverInfo>& aDriverInfo,
                               nsACString& aFailureId,
@@ -333,17 +333,17 @@ GfxInfo::GetFeatureStatusImpl(int32_t aF
 {
   NS_ENSURE_ARG_POINTER(aStatus);
   aSuggestedDriverVersion.SetIsVoid(true);
   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
   OperatingSystem os = OSXVersionToOperatingSystem(mOSXVersion);
   if (aOS)
     *aOS = os;
 
-  if (mShutdownOccurred) {
+  if (sShutdownOccured) {
     return NS_OK;
   }
 
   // Don't evaluate special cases when we're evaluating the downloaded blocklist.
   if (!aDriverInfo.Length()) {
     if (aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA) {
       // Blacklist all ATI cards on OSX, except for
       // 0x6760 and 0x9488
--- a/widget/uikit/GfxInfo.cpp
+++ b/widget/uikit/GfxInfo.cpp
@@ -147,40 +147,40 @@ NS_IMETHODIMP
 GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active)
 {
   return NS_ERROR_FAILURE;
 }
 
 const nsTArray<GfxDriverInfo>&
 GfxInfo::GetGfxDriverInfo()
 {
-  if (mDriverInfo->IsEmpty()) {
+  if (sDriverInfo->IsEmpty()) {
     APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Ios,
       (nsAString&) GfxDriverInfo::GetDeviceVendor(VendorAll), GfxDriverInfo::allDevices,
       nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_STATUS_OK,
       DRIVER_COMPARISON_IGNORED, GfxDriverInfo::allDriverVersions );
   }
 
-  return *mDriverInfo;
+  return *sDriverInfo;
 }
 
 nsresult
 GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
                               int32_t *aStatus,
                               nsAString & aSuggestedDriverVersion,
                               const nsTArray<GfxDriverInfo>& aDriverInfo,
                               OperatingSystem* aOS /* = nullptr */)
 {
   NS_ENSURE_ARG_POINTER(aStatus);
   aSuggestedDriverVersion.SetIsVoid(true);
   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
   if (aOS)
     *aOS = OperatingSystem::Ios;
 
-  if (mShutdownOccurred) {
+  if (sShutdownOccured) {
     return NS_OK;
   }
 
   // OpenGL layers are never blacklisted on iOS.
   // This early return is so we avoid potentially slow
   // GLStrings initialization on startup when we initialize GL layers.
   if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS ||
       aFeature == nsIGfxInfo::FEATURE_WEBGL_OPENGL ||
--- a/widget/windows/GfxInfo.cpp
+++ b/widget/windows/GfxInfo.cpp
@@ -1005,17 +1005,17 @@ DetectBrokenAVX()
   const unsigned AVX_CTRL_BITS = (1 << 1) | (1 << 2);
   return (_xgetbv(0) & AVX_CTRL_BITS) != AVX_CTRL_BITS;
 }
 #endif
 
 const nsTArray<GfxDriverInfo>&
 GfxInfo::GetGfxDriverInfo()
 {
-  if (!mDriverInfo->Length()) {
+  if (!sDriverInfo->Length()) {
     /*
      * It should be noted here that more specialized rules on certain features
      * should be inserted -before- more generalized restriction. As the first
      * match for feature/OS/device found in the list will be used for the final
      * blacklisting call.
      */
 
     /*
@@ -1430,17 +1430,17 @@ GfxInfo::GetGfxDriverInfo()
       (nsAString&) GfxDriverInfo::GetDeviceVendor(VendorNVIDIA), GfxDriverInfo::allDevices,
       nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
       DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_UNQUALIFIED_WEBRENDER_NVIDIA_8");
     APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Windows8_1,
       (nsAString&) GfxDriverInfo::GetDeviceVendor(VendorNVIDIA), GfxDriverInfo::allDevices,
       nsIGfxInfo::FEATURE_WEBRENDER, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
       DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_UNQUALIFIED_WEBRENDER_NVIDIA_8_1");
   }
-  return *mDriverInfo;
+  return *sDriverInfo;
 }
 
 nsresult
 GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
                               int32_t *aStatus,
                               nsAString & aSuggestedDriverVersion,
                               const nsTArray<GfxDriverInfo>& aDriverInfo,
                               nsACString& aFailureId,
@@ -1448,17 +1448,17 @@ GfxInfo::GetFeatureStatusImpl(int32_t aF
 {
   NS_ENSURE_ARG_POINTER(aStatus);
   aSuggestedDriverVersion.SetIsVoid(true);
   OperatingSystem os = WindowsVersionToOperatingSystem(mWindowsVersion);
   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
   if (aOS)
     *aOS = os;
 
-  if (mShutdownOccurred) {
+  if (sShutdownOccured) {
     return NS_OK;
   }
 
   // Don't evaluate special cases if we're checking the downloaded blocklist.
   if (!aDriverInfo.Length()) {
     nsAutoString adapterVendorID;
     nsAutoString adapterDeviceID;
     nsAutoString adapterDriverVersionString;