widget/GfxInfoBase.cpp

   1 /* vim: se cin sw=2 ts=2 et : */
   2 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include "mozilla/ArrayUtils.h"
   9
  10 #include "GfxInfoBase.h"
  11
  12 #include <mutex>  // std::call_once
  13
  14 #include "GfxDriverInfo.h"
  15 #include "js/Array.h"  // JS::GetArrayLength, JS::NewArrayObject
  16 #include "nsCOMPtr.h"
  17 #include "nsCOMArray.h"
  18 #include "nsString.h"
  19 #include "nsUnicharUtils.h"
  20 #include "nsVersionComparator.h"
  21 #include "mozilla/Services.h"
  22 #include "mozilla/Observer.h"
  23 #include "nsIObserver.h"
  24 #include "nsIObserverService.h"
  25 #include "nsIScreenManager.h"
  26 #include "nsTArray.h"
  27 #include "nsXULAppAPI.h"
  28 #include "nsIXULAppInfo.h"
  29 #include "mozilla/ClearOnShutdown.h"
  30 #include "mozilla/Preferences.h"
  31 #include "mozilla/StaticPrefs_gfx.h"
  32 #include "mozilla/gfx/2D.h"
  33 #include "mozilla/gfx/GPUProcessManager.h"
  34 #include "mozilla/gfx/Logging.h"
  35 #include "mozilla/gfx/gfxVars.h"
  36 #include "mozilla/layers/PaintThread.h"
  37
  38 #include "gfxPlatform.h"
  39 #include "gfxConfig.h"
  40 #include "DriverCrashGuard.h"
  41
  42 using namespace mozilla::widget;
  43 using namespace mozilla;
  44 using mozilla::MutexAutoLock;
  45
  46 nsTArray<GfxDriverInfo>* GfxInfoBase::sDriverInfo;
  47 StaticAutoPtr<nsTArray<gfx::GfxInfoFeatureStatus>> GfxInfoBase::sFeatureStatus;
  48 bool GfxInfoBase::sDriverInfoObserverInitialized;
  49 bool GfxInfoBase::sShutdownOccurred;
  50
  51 // Call this when setting sFeatureStatus to a non-null pointer to
  52 // ensure destruction even if the GfxInfo component is never instantiated.
  53 static void InitFeatureStatus(nsTArray<gfx::GfxInfoFeatureStatus>* aPtr) {
  54   static std::once_flag sOnce;
  55   std::call_once(sOnce, [] { ClearOnShutdown(&GfxInfoBase::sFeatureStatus); });
  56   GfxInfoBase::sFeatureStatus = aPtr;
  57 }
  58
  59 // Observes for shutdown so that the child GfxDriverInfo list is freed.
  60 class ShutdownObserver : public nsIObserver {
  61   virtual ~ShutdownObserver() = default;
  62
  63  public:
  64   ShutdownObserver() = default;
  65
  66   NS_DECL_ISUPPORTS
  67
  68   NS_IMETHOD Observe(nsISupports* subject, const char* aTopic,
  69                      const char16_t* aData) override {
  70     MOZ_ASSERT(strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0);
  71
  72     delete GfxInfoBase::sDriverInfo;
  73     GfxInfoBase::sDriverInfo = nullptr;
  74
  75     for (auto& deviceFamily : GfxDriverInfo::sDeviceFamilies) {
  76       delete deviceFamily;
  77       deviceFamily = nullptr;
  78     }
  79
  80     for (auto& desktop : GfxDriverInfo::sDesktopEnvironment) {
  81       delete desktop;
  82       desktop = nullptr;
  83     }
  84
  85     for (auto& windowProtocol : GfxDriverInfo::sWindowProtocol) {
  86       delete windowProtocol;
  87       windowProtocol = nullptr;
  88     }
  89
  90     for (auto& deviceVendor : GfxDriverInfo::sDeviceVendors) {
  91       delete deviceVendor;
  92       deviceVendor = nullptr;
  93     }
  94
  95     for (auto& driverVendor : GfxDriverInfo::sDriverVendors) {
  96       delete driverVendor;
  97       driverVendor = nullptr;
  98     }
  99
 100     GfxInfoBase::sShutdownOccurred = true;
 101
 102     return NS_OK;
 103   }
 104 };
 105
 106 NS_IMPL_ISUPPORTS(ShutdownObserver, nsIObserver)
 107
 108 static void InitGfxDriverInfoShutdownObserver() {
 109   if (GfxInfoBase::sDriverInfoObserverInitialized) return;
 110
 111   GfxInfoBase::sDriverInfoObserverInitialized = true;
 112
 113   nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
 114   if (!observerService) {
 115     NS_WARNING("Could not get observer service!");
 116     return;
 117   }
 118
 119   ShutdownObserver* obs = new ShutdownObserver();
 120   observerService->AddObserver(obs, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
 121 }
 122
 123 using namespace mozilla::widget;
 124 using namespace mozilla::gfx;
 125 using namespace mozilla;
 126
 127 NS_IMPL_ISUPPORTS(GfxInfoBase, nsIGfxInfo, nsIObserver,
 128                   nsISupportsWeakReference)
 129
 130 #define BLOCKLIST_PREF_BRANCH "gfx.blacklist."
 131 #define SUGGESTED_VERSION_PREF BLOCKLIST_PREF_BRANCH "suggested-driver-version"
 132
 133 static const char* GetPrefNameForFeature(int32_t aFeature) {
 134   const char* name = nullptr;
 135   switch (aFeature) {
 136     case nsIGfxInfo::FEATURE_DIRECT2D:
 137       name = BLOCKLIST_PREF_BRANCH "direct2d";
 138       break;
 139     case nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS:
 140       name = BLOCKLIST_PREF_BRANCH "layers.direct3d9";
 141       break;
 142     case nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS:
 143       name = BLOCKLIST_PREF_BRANCH "layers.direct3d10";
 144       break;
 145     case nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS:
 146       name = BLOCKLIST_PREF_BRANCH "layers.direct3d10-1";
 147       break;
 148     case nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS:
 149       name = BLOCKLIST_PREF_BRANCH "layers.direct3d11";
 150       break;
 151     case nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE:
 152       name = BLOCKLIST_PREF_BRANCH "direct3d11angle";
 153       break;
 154     case nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING:
 155       name = BLOCKLIST_PREF_BRANCH "hardwarevideodecoding";
 156       break;
 157     case nsIGfxInfo::FEATURE_OPENGL_LAYERS:
 158       name = BLOCKLIST_PREF_BRANCH "layers.opengl";
 159       break;
 160     case nsIGfxInfo::FEATURE_WEBGL_OPENGL:
 161       name = BLOCKLIST_PREF_BRANCH "webgl.opengl";
 162       break;
 163     case nsIGfxInfo::FEATURE_WEBGL_ANGLE:
 164       name = BLOCKLIST_PREF_BRANCH "webgl.angle";
 165       break;
 166     case nsIGfxInfo::FEATURE_WEBGL_MSAA:
 167       name = BLOCKLIST_PREF_BRANCH "webgl.msaa";
 168       break;
 169     case nsIGfxInfo::FEATURE_STAGEFRIGHT:
 170       name = BLOCKLIST_PREF_BRANCH "stagefright";
 171       break;
 172     case nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_H264:
 173       name = BLOCKLIST_PREF_BRANCH "webrtc.hw.acceleration.h264";
 174       break;
 175     case nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE:
 176       name = BLOCKLIST_PREF_BRANCH "webrtc.hw.acceleration.encode";
 177       break;
 178     case nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE:
 179       name = BLOCKLIST_PREF_BRANCH "webrtc.hw.acceleration.decode";
 180       break;
 181     case nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION:
 182       name = BLOCKLIST_PREF_BRANCH "canvas2d.acceleration";
 183       break;
 184     case nsIGfxInfo::FEATURE_DX_INTEROP2:
 185       name = BLOCKLIST_PREF_BRANCH "dx.interop2";
 186       break;
 187     case nsIGfxInfo::FEATURE_GPU_PROCESS:
 188       name = BLOCKLIST_PREF_BRANCH "gpu.process";
 189       break;
 190     case nsIGfxInfo::FEATURE_WEBGL2:
 191       name = BLOCKLIST_PREF_BRANCH "webgl2";
 192       break;
 193     case nsIGfxInfo::FEATURE_ADVANCED_LAYERS:
 194       name = BLOCKLIST_PREF_BRANCH "layers.advanced";
 195       break;
 196     case nsIGfxInfo::FEATURE_D3D11_KEYED_MUTEX:
 197       name = BLOCKLIST_PREF_BRANCH "d3d11.keyed.mutex";
 198       break;
 199     case nsIGfxInfo::FEATURE_WEBRENDER:
 200       name = BLOCKLIST_PREF_BRANCH "webrender";
 201       break;
 202     case nsIGfxInfo::FEATURE_WEBRENDER_COMPOSITOR:
 203       name = BLOCKLIST_PREF_BRANCH "webrender.compositor";
 204       break;
 205     case nsIGfxInfo::FEATURE_DX_NV12:
 206       name = BLOCKLIST_PREF_BRANCH "dx.nv12";
 207       break;
 208     case nsIGfxInfo::FEATURE_DX_P010:
 209       name = BLOCKLIST_PREF_BRANCH "dx.p010";
 210       break;
 211     case nsIGfxInfo::FEATURE_DX_P016:
 212       name = BLOCKLIST_PREF_BRANCH "dx.p016";
 213       break;
 214     case nsIGfxInfo::FEATURE_VP8_HW_DECODE:
 215     case nsIGfxInfo::FEATURE_VP9_HW_DECODE:
 216       // We don't provide prefs for these features as these are
 217       // not handling downloadable blocklist.
 218       break;
 219     case nsIGfxInfo::FEATURE_GL_SWIZZLE:
 220       name = BLOCKLIST_PREF_BRANCH "gl.swizzle";
 221       break;
 222     case nsIGfxInfo::FEATURE_WEBRENDER_SCISSORED_CACHE_CLEARS:
 223       name = BLOCKLIST_PREF_BRANCH "webrender.scissored_cache_clears";
 224       break;
 225     default:
 226       MOZ_ASSERT_UNREACHABLE("Unexpected nsIGfxInfo feature?!");
 227       break;
 228   }
 229
 230   return name;
 231 }
 232
 233 // Returns the value of the pref for the relevant feature in aValue.
 234 // If the pref doesn't exist, aValue is not touched, and returns false.
 235 static bool GetPrefValueForFeature(int32_t aFeature, int32_t& aValue,
 236                                    nsACString& aFailureId) {
 237   const char* prefname = GetPrefNameForFeature(aFeature);
 238   if (!prefname) return false;
 239
 240   aValue = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
 241   if (!NS_SUCCEEDED(Preferences::GetInt(prefname, &aValue))) {
 242     return false;
 243   }
 244
 245   nsCString failureprefname(prefname);
 246   failureprefname += ".failureid";
 247   nsAutoCString failureValue;
 248   nsresult rv = Preferences::GetCString(failureprefname.get(), failureValue);
 249   if (NS_SUCCEEDED(rv)) {
 250     aFailureId = failureValue.get();
 251   } else {
 252     aFailureId = "FEATURE_FAILURE_BLOCKLIST_PREF";
 253   }
 254
 255   return true;
 256 }
 257
 258 static void SetPrefValueForFeature(int32_t aFeature, int32_t aValue,
 259                                    const nsACString& aFailureId) {
 260   const char* prefname = GetPrefNameForFeature(aFeature);
 261   if (!prefname) return;
 262   if (XRE_IsParentProcess()) {
 263     GfxInfoBase::sFeatureStatus = nullptr;
 264   }
 265
 266   Preferences::SetInt(prefname, aValue);
 267   if (!aFailureId.IsEmpty()) {
 268     nsCString failureprefname(prefname);
 269     failureprefname += ".failureid";
 270     Preferences::SetCString(failureprefname.get(), aFailureId);
 271   }
 272 }
 273
 274 static void RemovePrefForFeature(int32_t aFeature) {
 275   const char* prefname = GetPrefNameForFeature(aFeature);
 276   if (!prefname) return;
 277
 278   if (XRE_IsParentProcess()) {
 279     GfxInfoBase::sFeatureStatus = nullptr;
 280   }
 281   Preferences::ClearUser(prefname);
 282 }
 283
 284 static bool GetPrefValueForDriverVersion(nsCString& aVersion) {
 285   return NS_SUCCEEDED(
 286       Preferences::GetCString(SUGGESTED_VERSION_PREF, aVersion));
 287 }
 288
 289 static void SetPrefValueForDriverVersion(const nsAString& aVersion) {
 290   Preferences::SetString(SUGGESTED_VERSION_PREF, aVersion);
 291 }
 292
 293 static void RemovePrefForDriverVersion() {
 294   Preferences::ClearUser(SUGGESTED_VERSION_PREF);
 295 }
 296
 297 static OperatingSystem BlocklistOSToOperatingSystem(const nsAString& os) {
 298   if (os.EqualsLiteral("WINNT 6.1"))
 299     return OperatingSystem::Windows7;
 300   else if (os.EqualsLiteral("WINNT 6.2"))
 301     return OperatingSystem::Windows8;
 302   else if (os.EqualsLiteral("WINNT 6.3"))
 303     return OperatingSystem::Windows8_1;
 304   else if (os.EqualsLiteral("WINNT 10.0"))
 305     return OperatingSystem::Windows10;
 306   else if (os.EqualsLiteral("Linux"))
 307     return OperatingSystem::Linux;
 308   else if (os.EqualsLiteral("Darwin 9"))
 309     return OperatingSystem::OSX10_5;
 310   else if (os.EqualsLiteral("Darwin 10"))
 311     return OperatingSystem::OSX10_6;
 312   else if (os.EqualsLiteral("Darwin 11"))
 313     return OperatingSystem::OSX10_7;
 314   else if (os.EqualsLiteral("Darwin 12"))
 315     return OperatingSystem::OSX10_8;
 316   else if (os.EqualsLiteral("Darwin 13"))
 317     return OperatingSystem::OSX10_9;
 318   else if (os.EqualsLiteral("Darwin 14"))
 319     return OperatingSystem::OSX10_10;
 320   else if (os.EqualsLiteral("Darwin 15"))
 321     return OperatingSystem::OSX10_11;
 322   else if (os.EqualsLiteral("Darwin 16"))
 323     return OperatingSystem::OSX10_12;
 324   else if (os.EqualsLiteral("Darwin 17"))
 325     return OperatingSystem::OSX10_13;
 326   else if (os.EqualsLiteral("Darwin 18"))
 327     return OperatingSystem::OSX10_14;
 328   else if (os.EqualsLiteral("Darwin 19"))
 329     return OperatingSystem::OSX10_15;
 330   else if (os.EqualsLiteral("Darwin 20"))
 331     return OperatingSystem::OSX10_16;
 332   else if (os.EqualsLiteral("Android"))
 333     return OperatingSystem::Android;
 334   // For historical reasons, "All" in blocklist means "All Windows"
 335   else if (os.EqualsLiteral("All"))
 336     return OperatingSystem::Windows;
 337
 338   return OperatingSystem::Unknown;
 339 }
 340
 341 static GfxDeviceFamily* BlocklistDevicesToDeviceFamily(
 342     nsTArray<nsCString>& devices) {
 343   if (devices.Length() == 0) return nullptr;
 344
 345   // For each device, get its device ID, and return a freshly-allocated
 346   // GfxDeviceFamily with the contents of that array.
 347   GfxDeviceFamily* deviceIds = new GfxDeviceFamily;
 348
 349   for (uint32_t i = 0; i < devices.Length(); ++i) {
 350     // We make sure we don't add any "empty" device entries to the array, so
 351     // we don't need to check if devices[i] is empty.
 352     deviceIds->Append(NS_ConvertUTF8toUTF16(devices[i]));
 353   }
 354
 355   return deviceIds;
 356 }
 357
 358 static int32_t BlocklistFeatureToGfxFeature(const nsAString& aFeature) {
 359   MOZ_ASSERT(!aFeature.IsEmpty());
 360   if (aFeature.EqualsLiteral("DIRECT2D"))
 361     return nsIGfxInfo::FEATURE_DIRECT2D;
 362   else if (aFeature.EqualsLiteral("DIRECT3D_9_LAYERS"))
 363     return nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS;
 364   else if (aFeature.EqualsLiteral("DIRECT3D_10_LAYERS"))
 365     return nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS;
 366   else if (aFeature.EqualsLiteral("DIRECT3D_10_1_LAYERS"))
 367     return nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS;
 368   else if (aFeature.EqualsLiteral("DIRECT3D_11_LAYERS"))
 369     return nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS;
 370   else if (aFeature.EqualsLiteral("DIRECT3D_11_ANGLE"))
 371     return nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE;
 372   else if (aFeature.EqualsLiteral("HARDWARE_VIDEO_DECODING"))
 373     return nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING;
 374   else if (aFeature.EqualsLiteral("OPENGL_LAYERS"))
 375     return nsIGfxInfo::FEATURE_OPENGL_LAYERS;
 376   else if (aFeature.EqualsLiteral("WEBGL_OPENGL"))
 377     return nsIGfxInfo::FEATURE_WEBGL_OPENGL;
 378   else if (aFeature.EqualsLiteral("WEBGL_ANGLE"))
 379     return nsIGfxInfo::FEATURE_WEBGL_ANGLE;
 380   else if (aFeature.EqualsLiteral("WEBGL_MSAA"))
 381     return nsIGfxInfo::FEATURE_WEBGL_MSAA;
 382   else if (aFeature.EqualsLiteral("STAGEFRIGHT"))
 383     return nsIGfxInfo::FEATURE_STAGEFRIGHT;
 384   else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_ENCODE"))
 385     return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE;
 386   else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_DECODE"))
 387     return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE;
 388   else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_H264"))
 389     return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_H264;
 390   else if (aFeature.EqualsLiteral("CANVAS2D_ACCELERATION"))
 391     return nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION;
 392   else if (aFeature.EqualsLiteral("DX_INTEROP2"))
 393     return nsIGfxInfo::FEATURE_DX_INTEROP2;
 394   else if (aFeature.EqualsLiteral("GPU_PROCESS"))
 395     return nsIGfxInfo::FEATURE_GPU_PROCESS;
 396   else if (aFeature.EqualsLiteral("WEBGL2"))
 397     return nsIGfxInfo::FEATURE_WEBGL2;
 398   else if (aFeature.EqualsLiteral("ADVANCED_LAYERS"))
 399     return nsIGfxInfo::FEATURE_ADVANCED_LAYERS;
 400   else if (aFeature.EqualsLiteral("D3D11_KEYED_MUTEX"))
 401     return nsIGfxInfo::FEATURE_D3D11_KEYED_MUTEX;
 402   else if (aFeature.EqualsLiteral("WEBRENDER"))
 403     return nsIGfxInfo::FEATURE_WEBRENDER;
 404   else if (aFeature.EqualsLiteral("WEBRENDER_COMPOSITOR"))
 405     return nsIGfxInfo::FEATURE_WEBRENDER_COMPOSITOR;
 406   else if (aFeature.EqualsLiteral("DX_NV12"))
 407     return nsIGfxInfo::FEATURE_DX_NV12;
 408   // We do not support FEATURE_VP8_HW_DECODE and FEATURE_VP9_HW_DECODE
 409   // in downloadable blocklist.
 410   else if (aFeature.EqualsLiteral("GL_SWIZZLE"))
 411     return nsIGfxInfo::FEATURE_GL_SWIZZLE;
 412   else if (aFeature.EqualsLiteral("WEBRENDER_SCISSORED_CACHE_CLEARS"))
 413     return nsIGfxInfo::FEATURE_WEBRENDER_SCISSORED_CACHE_CLEARS;
 414
 415   // If we don't recognize the feature, it may be new, and something
 416   // this version doesn't understand.  So, nothing to do.  This is
 417   // different from feature not being specified at all, in which case
 418   // this method should not get called and we should continue with the
 419   // "all features" blocklisting.
 420   return -1;
 421 }
 422
 423 static int32_t BlocklistFeatureStatusToGfxFeatureStatus(
 424     const nsAString& aStatus) {
 425   if (aStatus.EqualsLiteral("STATUS_OK"))
 426     return nsIGfxInfo::FEATURE_STATUS_OK;
 427   else if (aStatus.EqualsLiteral("BLOCKED_DRIVER_VERSION"))
 428     return nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 429   else if (aStatus.EqualsLiteral("BLOCKED_DEVICE"))
 430     return nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
 431   else if (aStatus.EqualsLiteral("DISCOURAGED"))
 432     return nsIGfxInfo::FEATURE_DISCOURAGED;
 433   else if (aStatus.EqualsLiteral("BLOCKED_OS_VERSION"))
 434     return nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
 435   else if (aStatus.EqualsLiteral("DENIED"))
 436     return nsIGfxInfo::FEATURE_DENIED;
 437   else if (aStatus.EqualsLiteral("ALLOW_QUALIFIED"))
 438     return nsIGfxInfo::FEATURE_ALLOW_QUALIFIED;
 439   else if (aStatus.EqualsLiteral("ALLOW_ALWAYS"))
 440     return nsIGfxInfo::FEATURE_ALLOW_ALWAYS;
 441
 442   // Do not allow it to set STATUS_UNKNOWN.  Also, we are not
 443   // expecting the "mismatch" status showing up here.
 444
 445   return nsIGfxInfo::FEATURE_STATUS_OK;
 446 }
 447
 448 static VersionComparisonOp BlocklistComparatorToComparisonOp(
 449     const nsAString& op) {
 450   if (op.EqualsLiteral("LESS_THAN"))
 451     return DRIVER_LESS_THAN;
 452   else if (op.EqualsLiteral("BUILD_ID_LESS_THAN"))
 453     return DRIVER_BUILD_ID_LESS_THAN;
 454   else if (op.EqualsLiteral("LESS_THAN_OR_EQUAL"))
 455     return DRIVER_LESS_THAN_OR_EQUAL;
 456   else if (op.EqualsLiteral("BUILD_ID_LESS_THAN_OR_EQUAL"))
 457     return DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL;
 458   else if (op.EqualsLiteral("GREATER_THAN"))
 459     return DRIVER_GREATER_THAN;
 460   else if (op.EqualsLiteral("GREATER_THAN_OR_EQUAL"))
 461     return DRIVER_GREATER_THAN_OR_EQUAL;
 462   else if (op.EqualsLiteral("EQUAL"))
 463     return DRIVER_EQUAL;
 464   else if (op.EqualsLiteral("NOT_EQUAL"))
 465     return DRIVER_NOT_EQUAL;
 466   else if (op.EqualsLiteral("BETWEEN_EXCLUSIVE"))
 467     return DRIVER_BETWEEN_EXCLUSIVE;
 468   else if (op.EqualsLiteral("BETWEEN_INCLUSIVE"))
 469     return DRIVER_BETWEEN_INCLUSIVE;
 470   else if (op.EqualsLiteral("BETWEEN_INCLUSIVE_START"))
 471     return DRIVER_BETWEEN_INCLUSIVE_START;
 472
 473   return DRIVER_COMPARISON_IGNORED;
 474 }
 475
 476 /*
 477   Deserialize Blocklist entries from string.
 478   e.g:
 479   os:WINNT 6.0\tvendor:0x8086\tdevices:0x2582,0x2782\tfeature:DIRECT3D_10_LAYERS\tfeatureStatus:BLOCKED_DRIVER_VERSION\tdriverVersion:8.52.322.2202\tdriverVersionComparator:LESS_THAN_OR_EQUAL
 480 */
 481 static bool BlocklistEntryToDriverInfo(const nsACString& aBlocklistEntry,
 482                                        GfxDriverInfo& aDriverInfo) {
 483   // If we get an application version to be zero, something is not working
 484   // and we are not going to bother checking the blocklist versions.
 485   // See TestGfxWidgets.cpp for how version comparison works.
 486   // <versionRange minVersion="42.0a1" maxVersion="45.0"></versionRange>
 487   static mozilla::Version zeroV("0");
 488   static mozilla::Version appV(GfxInfoBase::GetApplicationVersion().get());
 489   if (appV <= zeroV) {
 490     gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false))
 491         << "Invalid application version "
 492         << GfxInfoBase::GetApplicationVersion().get();
 493   }
 494
 495   aDriverInfo.mRuleId = "FEATURE_FAILURE_DL_BLOCKLIST_NO_ID"_ns;
 496
 497   for (const auto& keyValue : aBlocklistEntry.Split('\t')) {
 498     nsTArray<nsCString> splitted;
 499     ParseString(keyValue, ':', splitted);
 500     if (splitted.Length() != 2) {
 501       // If we don't recognize the input data, we do not want to proceed.
 502       gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false))
 503           << "Unrecognized data " << nsCString(keyValue).get();
 504       return false;
 505     }
 506     const nsCString& key = splitted[0];
 507     const nsCString& value = splitted[1];
 508     NS_ConvertUTF8toUTF16 dataValue(value);
 509
 510     if (value.Length() == 0) {
 511       // Safety check for empty values.
 512       gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false))
 513           << "Empty value for " << key.get();
 514       return false;
 515     }
 516
 517     if (key.EqualsLiteral("blockID")) {
 518       nsCString blockIdStr = "FEATURE_FAILURE_DL_BLOCKLIST_"_ns + value;
 519       aDriverInfo.mRuleId = blockIdStr.get();
 520     } else if (key.EqualsLiteral("os")) {
 521       aDriverInfo.mOperatingSystem = BlocklistOSToOperatingSystem(dataValue);
 522     } else if (key.EqualsLiteral("osversion")) {
 523       aDriverInfo.mOperatingSystemVersion = strtoul(value.get(), nullptr, 10);
 524     } else if (key.EqualsLiteral("desktopEnvironment")) {
 525       aDriverInfo.mDesktopEnvironment = dataValue;
 526     } else if (key.EqualsLiteral("windowProtocol")) {
 527       aDriverInfo.mWindowProtocol = dataValue;
 528     } else if (key.EqualsLiteral("vendor")) {
 529       aDriverInfo.mAdapterVendor = dataValue;
 530     } else if (key.EqualsLiteral("driverVendor")) {
 531       aDriverInfo.mDriverVendor = dataValue;
 532     } else if (key.EqualsLiteral("feature")) {
 533       aDriverInfo.mFeature = BlocklistFeatureToGfxFeature(dataValue);
 534       if (aDriverInfo.mFeature < 0) {
 535         // If we don't recognize the feature, we do not want to proceed.
 536         gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false))
 537             << "Unrecognized feature " << value.get();
 538         return false;
 539       }
 540     } else if (key.EqualsLiteral("featureStatus")) {
 541       aDriverInfo.mFeatureStatus =
 542           BlocklistFeatureStatusToGfxFeatureStatus(dataValue);
 543     } else if (key.EqualsLiteral("driverVersion")) {
 544       uint64_t version;
 545       if (ParseDriverVersion(dataValue, &version))
 546         aDriverInfo.mDriverVersion = version;
 547     } else if (key.EqualsLiteral("driverVersionMax")) {
 548       uint64_t version;
 549       if (ParseDriverVersion(dataValue, &version))
 550         aDriverInfo.mDriverVersionMax = version;
 551     } else if (key.EqualsLiteral("driverVersionComparator")) {
 552       aDriverInfo.mComparisonOp = BlocklistComparatorToComparisonOp(dataValue);
 553     } else if (key.EqualsLiteral("model")) {
 554       aDriverInfo.mModel = dataValue;
 555     } else if (key.EqualsLiteral("product")) {
 556       aDriverInfo.mProduct = dataValue;
 557     } else if (key.EqualsLiteral("manufacturer")) {
 558       aDriverInfo.mManufacturer = dataValue;
 559     } else if (key.EqualsLiteral("hardware")) {
 560       aDriverInfo.mHardware = dataValue;
 561     } else if (key.EqualsLiteral("versionRange")) {
 562       nsTArray<nsCString> versionRange;
 563       ParseString(value, ',', versionRange);
 564       if (versionRange.Length() != 2) {
 565         gfxCriticalErrorOnce(CriticalLog::DefaultOptions(false))
 566             << "Unrecognized versionRange " << value.get();
 567         return false;
 568       }
 569       const nsCString& minValue = versionRange[0];
 570       const nsCString& maxValue = versionRange[1];
 571
 572       mozilla::Version minV(minValue.get());
 573       mozilla::Version maxV(maxValue.get());
 574
 575       if (minV > zeroV && !(appV >= minV)) {
 576         // The version of the application is less than the minimal version
 577         // this blocklist entry applies to, so we can just ignore it by
 578         // returning false and letting the caller deal with it.
 579         return false;
 580       }
 581       if (maxV > zeroV && !(appV <= maxV)) {
 582         // The version of the application is more than the maximal version
 583         // this blocklist entry applies to, so we can just ignore it by
 584         // returning false and letting the caller deal with it.
 585         return false;
 586       }
 587     } else if (key.EqualsLiteral("devices")) {
 588       nsTArray<nsCString> devices;
 589       ParseString(value, ',', devices);
 590       GfxDeviceFamily* deviceIds = BlocklistDevicesToDeviceFamily(devices);
 591       if (deviceIds) {
 592         // Get GfxDriverInfo to adopt the devices array we created.
 593         aDriverInfo.mDeleteDevices = true;
 594         aDriverInfo.mDevices = deviceIds;
 595       }
 596     }
 597     // We explicitly ignore unknown elements.
 598   }
 599
 600   return true;
 601 }
 602
 603 static void BlocklistEntriesToDriverInfo(
 604     const nsTSubstringSplitter<char>& aBlocklistEntries,
 605     nsTArray<GfxDriverInfo>& aDriverInfo) {
 606   aDriverInfo.Clear();
 607   const uint32_t n =
 608       std::distance(aBlocklistEntries.begin(), aBlocklistEntries.end());
 609   aDriverInfo.SetLength(n);
 610
 611   for (uint32_t i = 0; i < n; ++i) {
 612     const nsDependentCSubstring& blocklistEntry = aBlocklistEntries.Get(i);
 613     GfxDriverInfo di;
 614     if (BlocklistEntryToDriverInfo(blocklistEntry, di)) {
 615       aDriverInfo[i] = di;
 616       // Prevent di falling out of scope from destroying the devices.
 617       di.mDeleteDevices = false;
 618     }
 619   }
 620 }
 621
 622 NS_IMETHODIMP
 623 GfxInfoBase::Observe(nsISupports* aSubject, const char* aTopic,
 624                      const char16_t* aData) {
 625   if (strcmp(aTopic, "blocklist-data-gfxItems") == 0) {
 626     nsTArray<GfxDriverInfo> driverInfo;
 627     NS_ConvertUTF16toUTF8 utf8Data(aData);
 628     BlocklistEntriesToDriverInfo(utf8Data.Split('\n'), driverInfo);
 629     EvaluateDownloadedBlocklist(driverInfo);
 630   }
 631
 632   return NS_OK;
 633 }
 634
 635 GfxInfoBase::GfxInfoBase() : mScreenPixels(INT64_MAX), mMutex("GfxInfoBase") {}
 636
 637 GfxInfoBase::~GfxInfoBase() = default;
 638
 639 nsresult GfxInfoBase::Init() {
 640   InitGfxDriverInfoShutdownObserver();
 641
 642   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
 643   if (os) {
 644     os->AddObserver(this, "blocklist-data-gfxItems", true);
 645   }
 646
 647   return NS_OK;
 648 }
 649
 650 void GfxInfoBase::GetData() {
 651   if (mScreenPixels != INT64_MAX) {
 652     // Already initialized.
 653     return;
 654   }
 655
 656   nsCOMPtr<nsIScreenManager> manager =
 657       do_GetService("@mozilla.org/gfx/screenmanager;1");
 658   if (!manager) {
 659     MOZ_ASSERT_UNREACHABLE("failed to get nsIScreenManager");
 660     return;
 661   }
 662
 663   manager->GetTotalScreenPixels(&mScreenPixels);
 664 }
 665
 666 NS_IMETHODIMP
 667 GfxInfoBase::GetFeatureStatus(int32_t aFeature, nsACString& aFailureId,
 668                               int32_t* aStatus) {
 669   // Ignore the gfx.blocklist.all pref on release and beta.
 670 #if defined(RELEASE_OR_BETA)
 671   int32_t blocklistAll = 0;
 672 #else
 673   int32_t blocklistAll = StaticPrefs::gfx_blocklist_all_AtStartup();
 674 #endif
 675   if (blocklistAll > 0) {
 676     gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false))
 677         << "Forcing blocklisting all features";
 678     *aStatus = FEATURE_BLOCKED_DEVICE;
 679     aFailureId = "FEATURE_FAILURE_BLOCK_ALL";
 680     return NS_OK;
 681   } else if (blocklistAll < 0) {
 682     gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false))
 683         << "Ignoring any feature blocklisting.";
 684     *aStatus = FEATURE_STATUS_OK;
 685     return NS_OK;
 686   }
 687
 688   if (GetPrefValueForFeature(aFeature, *aStatus, aFailureId)) {
 689     return NS_OK;
 690   }
 691
 692   if (XRE_IsContentProcess() || XRE_IsGPUProcess()) {
 693     // Use the cached data received from the parent process.
 694     MOZ_ASSERT(sFeatureStatus);
 695     bool success = false;
 696     for (const auto& fs : *sFeatureStatus) {
 697       if (fs.feature() == aFeature) {
 698         aFailureId = fs.failureId();
 699         *aStatus = fs.status();
 700         success = true;
 701         break;
 702       }
 703     }
 704     return success ? NS_OK : NS_ERROR_FAILURE;
 705   }
 706
 707   nsString version;
 708   nsTArray<GfxDriverInfo> driverInfo;
 709   nsresult rv =
 710       GetFeatureStatusImpl(aFeature, aStatus, version, driverInfo, aFailureId);
 711   return rv;
 712 }
 713
 714 nsTArray<gfx::GfxInfoFeatureStatus> GfxInfoBase::GetAllFeatures() {
 715   MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
 716   if (!sFeatureStatus) {
 717     InitFeatureStatus(new nsTArray<gfx::GfxInfoFeatureStatus>());
 718     for (int32_t i = 1; i <= nsIGfxInfo::FEATURE_MAX_VALUE; ++i) {
 719       int32_t status = 0;
 720       nsAutoCString failureId;
 721       GetFeatureStatus(i, failureId, &status);
 722       gfx::GfxInfoFeatureStatus gfxFeatureStatus;
 723       gfxFeatureStatus.feature() = i;
 724       gfxFeatureStatus.status() = status;
 725       gfxFeatureStatus.failureId() = failureId;
 726       sFeatureStatus->AppendElement(gfxFeatureStatus);
 727     }
 728   }
 729
 730   nsTArray<gfx::GfxInfoFeatureStatus> features;
 731   for (const auto& status : *sFeatureStatus) {
 732     gfx::GfxInfoFeatureStatus copy = status;
 733     features.AppendElement(copy);
 734   }
 735   return features;
 736 }
 737
 738 inline bool MatchingAllowStatus(int32_t aStatus) {
 739   switch (aStatus) {
 740     case nsIGfxInfo::FEATURE_ALLOW_ALWAYS:
 741     case nsIGfxInfo::FEATURE_ALLOW_QUALIFIED:
 742       return true;
 743     default:
 744       return false;
 745   }
 746 }
 747
 748 // Matching OS go somewhat beyond the simple equality check because of the
 749 // "All Windows" and "All OS X" variations.
 750 //
 751 // aBlockedOS is describing the system(s) we are trying to block.
 752 // aSystemOS is describing the system we are running on.
 753 //
 754 // aSystemOS should not be "Windows" or "OSX" - it should be set to
 755 // a particular version instead.
 756 // However, it is valid for aBlockedOS to be one of those generic values,
 757 // as we could be blocking all of the versions.
 758 inline bool MatchingOperatingSystems(OperatingSystem aBlockedOS,
 759                                      OperatingSystem aSystemOS,
 760                                      uint32_t aSystemOSBuild) {
 761   MOZ_ASSERT(aSystemOS != OperatingSystem::Windows &&
 762              aSystemOS != OperatingSystem::OSX);
 763
 764   // If the block entry OS is unknown, it doesn't match
 765   if (aBlockedOS == OperatingSystem::Unknown) {
 766     return false;
 767   }
 768
 769 #if defined(XP_WIN)
 770   if (aBlockedOS == OperatingSystem::Windows) {
 771     // We do want even "unknown" aSystemOS to fall under "all windows"
 772     return true;
 773   }
 774
 775   constexpr uint32_t kMinWin10BuildNumber = 18362;
 776   if (aBlockedOS == OperatingSystem::RecentWindows10 &&
 777       aSystemOS == OperatingSystem::Windows10) {
 778     // For allowlist purposes, we sometimes want to restrict to only recent
 779     // versions of Windows 10. This is a bit of a kludge but easier than adding
 780     // complicated blocklist infrastructure for build ID comparisons like driver
 781     // versions.
 782     return aSystemOSBuild >= kMinWin10BuildNumber;
 783   }
 784
 785   if (aBlockedOS == OperatingSystem::NotRecentWindows10) {
 786     if (aSystemOS == OperatingSystem::Windows10) {
 787       return aSystemOSBuild < kMinWin10BuildNumber;
 788     } else {
 789       return true;
 790     }
 791   }
 792 #endif
 793
 794 #if defined(XP_MACOSX)
 795   if (aBlockedOS == OperatingSystem::OSX) {
 796     // We do want even "unknown" aSystemOS to fall under "all OS X"
 797     return true;
 798   }
 799 #endif
 800
 801   return aSystemOS == aBlockedOS;
 802 }
 803
 804 inline bool MatchingBattery(BatteryStatus aBatteryStatus, bool aHasBattery) {
 805   switch (aBatteryStatus) {
 806     case BatteryStatus::All:
 807       return true;
 808     case BatteryStatus::None:
 809       return !aHasBattery;
 810     case BatteryStatus::Present:
 811       return aHasBattery;
 812   }
 813
 814   MOZ_ASSERT_UNREACHABLE("bad battery status");
 815   return false;
 816 }
 817
 818 inline bool MatchingScreenSize(ScreenSizeStatus aScreenStatus,
 819                                int64_t aScreenPixels) {
 820   constexpr int64_t kMaxSmallPixels = 2304000;   // 1920x1200
 821   constexpr int64_t kMaxMediumPixels = 4953600;  // 3440x1440
 822
 823   switch (aScreenStatus) {
 824     case ScreenSizeStatus::All:
 825       return true;
 826     case ScreenSizeStatus::Small:
 827       return aScreenPixels <= kMaxSmallPixels;
 828     case ScreenSizeStatus::SmallAndMedium:
 829       return aScreenPixels <= kMaxMediumPixels;
 830     case ScreenSizeStatus::Medium:
 831       return aScreenPixels > kMaxSmallPixels &&
 832              aScreenPixels <= kMaxMediumPixels;
 833     case ScreenSizeStatus::MediumAndLarge:
 834       return aScreenPixels > kMaxSmallPixels;
 835     case ScreenSizeStatus::Large:
 836       return aScreenPixels > kMaxMediumPixels;
 837   }
 838
 839   MOZ_ASSERT_UNREACHABLE("bad screen status");
 840   return false;
 841 }
 842
 843 int32_t GfxInfoBase::FindBlocklistedDeviceInList(
 844     const nsTArray<GfxDriverInfo>& info, nsAString& aSuggestedVersion,
 845     int32_t aFeature, nsACString& aFailureId, OperatingSystem os,
 846     bool aForAllowing) {
 847   int32_t status = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
 848
 849   // Some properties are not available on all platforms.
 850   nsAutoString desktopEnvironment;
 851   nsresult rv = GetDesktopEnvironment(desktopEnvironment);
 852   if (NS_FAILED(rv) && rv != NS_ERROR_NOT_IMPLEMENTED) {
 853     return 0;
 854   }
 855
 856   nsAutoString windowProtocol;
 857   rv = GetWindowProtocol(windowProtocol);
 858   if (NS_FAILED(rv) && rv != NS_ERROR_NOT_IMPLEMENTED) {
 859     return 0;
 860   }
 861
 862   bool hasBattery = false;
 863   rv = GetHasBattery(&hasBattery);
 864   if (NS_FAILED(rv) && rv != NS_ERROR_NOT_IMPLEMENTED) {
 865     return 0;
 866   }
 867
 868   uint32_t osBuild = OperatingSystemBuild();
 869
 870   // Get the adapters once then reuse below
 871   nsAutoString adapterVendorID[2];
 872   nsAutoString adapterDeviceID[2];
 873   nsAutoString adapterDriverVendor[2];
 874   nsAutoString adapterDriverVersionString[2];
 875   bool adapterInfoFailed[2];
 876
 877   adapterInfoFailed[0] =
 878       (NS_FAILED(GetAdapterVendorID(adapterVendorID[0])) ||
 879        NS_FAILED(GetAdapterDeviceID(adapterDeviceID[0])) ||
 880        NS_FAILED(GetAdapterDriverVendor(adapterDriverVendor[0])) ||
 881        NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString[0])));
 882   adapterInfoFailed[1] =
 883       (NS_FAILED(GetAdapterVendorID2(adapterVendorID[1])) ||
 884        NS_FAILED(GetAdapterDeviceID2(adapterDeviceID[1])) ||
 885        NS_FAILED(GetAdapterDriverVendor2(adapterDriverVendor[1])) ||
 886        NS_FAILED(GetAdapterDriverVersion2(adapterDriverVersionString[1])));
 887   // No point in going on if we don't have adapter info
 888   if (adapterInfoFailed[0] && adapterInfoFailed[1]) {
 889     return 0;
 890   }
 891
 892 #if defined(XP_WIN) || defined(ANDROID) || defined(MOZ_X11)
 893   uint64_t driverVersion[2] = {0, 0};
 894   if (!adapterInfoFailed[0]) {
 895     ParseDriverVersion(adapterDriverVersionString[0], &driverVersion[0]);
 896   }
 897   if (!adapterInfoFailed[1]) {
 898     ParseDriverVersion(adapterDriverVersionString[1], &driverVersion[1]);
 899   }
 900 #endif
 901
 902   uint32_t i = 0;
 903   for (; i < info.Length(); i++) {
 904     // If the status is FEATURE_ALLOW_*, then it is for the allowlist, not
 905     // blocklisting. Only consider entries for our search mode.
 906     if (MatchingAllowStatus(info[i].mFeatureStatus) != aForAllowing) {
 907       continue;
 908     }
 909
 910     // If we don't have the info for this GPU, no need to check further.
 911     // It is unclear that we would ever have a mixture of 1st and 2nd
 912     // GPU, but leaving the code in for that possibility for now.
 913     // (Actually, currently mGpu2 will never be true, so this can
 914     // be optimized out.)
 915     uint32_t infoIndex = info[i].mGpu2 ? 1 : 0;
 916     if (adapterInfoFailed[infoIndex]) {
 917       continue;
 918     }
 919
 920     // Do the operating system check first, no point in getting the driver
 921     // info if we won't need to use it.
 922     if (!MatchingOperatingSystems(info[i].mOperatingSystem, os, osBuild)) {
 923       continue;
 924     }
 925
 926     if (info[i].mOperatingSystemVersion &&
 927         info[i].mOperatingSystemVersion != OperatingSystemVersion()) {
 928       continue;
 929     }
 930
 931     if (!MatchingBattery(info[i].mBattery, hasBattery)) {
 932       continue;
 933     }
 934
 935     if (!MatchingScreenSize(info[i].mScreen, mScreenPixels)) {
 936       continue;
 937     }
 938
 939     if (!DoesDesktopEnvironmentMatch(info[i].mDesktopEnvironment,
 940                                      desktopEnvironment)) {
 941       continue;
 942     }
 943
 944     if (!DoesWindowProtocolMatch(info[i].mWindowProtocol, windowProtocol)) {
 945       continue;
 946     }
 947
 948     if (!DoesVendorMatch(info[i].mAdapterVendor, adapterVendorID[infoIndex])) {
 949       continue;
 950     }
 951
 952     if (!DoesDriverVendorMatch(info[i].mDriverVendor,
 953                                adapterDriverVendor[infoIndex])) {
 954       continue;
 955     }
 956
 957     if (info[i].mDevices && !info[i].mDevices->IsEmpty()) {
 958       nsresult rv = info[i].mDevices->Contains(adapterDeviceID[infoIndex]);
 959       if (rv == NS_ERROR_NOT_AVAILABLE) {
 960         // Not found
 961         continue;
 962       }
 963       if (rv != NS_OK) {
 964         // Failed to search, allowlist should not match, blocklist should match
 965         // for safety reasons
 966         if (aForAllowing) {
 967           continue;
 968         }
 969         break;
 970       }
 971     }
 972
 973     bool match = false;
 974
 975     if (!info[i].mHardware.IsEmpty() && !info[i].mHardware.Equals(Hardware())) {
 976       continue;
 977     }
 978     if (!info[i].mModel.IsEmpty() && !info[i].mModel.Equals(Model())) {
 979       continue;
 980     }
 981     if (!info[i].mProduct.IsEmpty() && !info[i].mProduct.Equals(Product())) {
 982       continue;
 983     }
 984     if (!info[i].mManufacturer.IsEmpty() &&
 985         !info[i].mManufacturer.Equals(Manufacturer())) {
 986       continue;
 987     }
 988
 989 #if defined(XP_WIN) || defined(ANDROID) || defined(MOZ_X11)
 990     switch (info[i].mComparisonOp) {
 991       case DRIVER_LESS_THAN:
 992         match = driverVersion[infoIndex] < info[i].mDriverVersion;
 993         break;
 994       case DRIVER_BUILD_ID_LESS_THAN:
 995         match = (driverVersion[infoIndex] & 0xFFFF) < info[i].mDriverVersion;
 996         break;
 997       case DRIVER_LESS_THAN_OR_EQUAL:
 998         match = driverVersion[infoIndex] <= info[i].mDriverVersion;
 999         break;
1000       case DRIVER_BUILD_ID_LESS_THAN_OR_EQUAL:
1001         match = (driverVersion[infoIndex] & 0xFFFF) <= info[i].mDriverVersion;
1002         break;
1003       case DRIVER_GREATER_THAN:
1004         match = driverVersion[infoIndex] > info[i].mDriverVersion;
1005         break;
1006       case DRIVER_GREATER_THAN_OR_EQUAL:
1007         match = driverVersion[infoIndex] >= info[i].mDriverVersion;
1008         break;
1009       case DRIVER_EQUAL:
1010         match = driverVersion[infoIndex] == info[i].mDriverVersion;
1011         break;
1012       case DRIVER_NOT_EQUAL:
1013         match = driverVersion[infoIndex] != info[i].mDriverVersion;
1014         break;
1015       case DRIVER_BETWEEN_EXCLUSIVE:
1016         match = driverVersion[infoIndex] > info[i].mDriverVersion &&
1017                 driverVersion[infoIndex] < info[i].mDriverVersionMax;
1018         break;
1019       case DRIVER_BETWEEN_INCLUSIVE:
1020         match = driverVersion[infoIndex] >= info[i].mDriverVersion &&
1021                 driverVersion[infoIndex] <= info[i].mDriverVersionMax;
1022         break;
1023       case DRIVER_BETWEEN_INCLUSIVE_START:
1024         match = driverVersion[infoIndex] >= info[i].mDriverVersion &&
1025                 driverVersion[infoIndex] < info[i].mDriverVersionMax;
1026         break;
1027       case DRIVER_COMPARISON_IGNORED:
1028         // We don't have a comparison op, so we match everything.
1029         match = true;
1030         break;
1031       default:
1032         NS_WARNING("Bogus op in GfxDriverInfo");
1033         break;
1034     }
1035 #else
1036     // We don't care what driver version it was. We only check OS version and if
1037     // the device matches.
1038     match = true;
1039 #endif
1040
1041     if (match || info[i].mDriverVersion == GfxDriverInfo::allDriverVersions) {
1042       if (info[i].mFeature == GfxDriverInfo::allFeatures ||
1043           info[i].mFeature == aFeature) {
1044         status = info[i].mFeatureStatus;
1045         if (!info[i].mRuleId.IsEmpty()) {
1046           aFailureId = info[i].mRuleId.get();
1047         } else {
1048           aFailureId = "FEATURE_FAILURE_DL_BLOCKLIST_NO_ID";
1049         }
1050         break;
1051       }
1052     }
1053   }
1054
1055 #if defined(XP_WIN)
1056   // As a very special case, we block D2D on machines with an NVidia 310M GPU
1057   // as either the primary or secondary adapter.  D2D is also blocked when the
1058   // NV 310M is the primary adapter (using the standard blocklisting mechanism).
1059   // If the primary GPU already matched something in the blocklist then we
1060   // ignore this special rule.  See bug 1008759.
1061   if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN &&
1062       (aFeature == nsIGfxInfo::FEATURE_DIRECT2D)) {
1063     if (!adapterInfoFailed[1]) {
1064       nsAString& nvVendorID =
1065           (nsAString&)GfxDriverInfo::GetDeviceVendor(DeviceVendor::NVIDIA);
1066       const nsString nv310mDeviceId = u"0x0A70"_ns;
1067       if (nvVendorID.Equals(adapterVendorID[1],
1068                             nsCaseInsensitiveStringComparator) &&
1069           nv310mDeviceId.Equals(adapterDeviceID[1],
1070                                 nsCaseInsensitiveStringComparator)) {
1071         status = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
1072         aFailureId = "FEATURE_FAILURE_D2D_NV310M_BLOCK";
1073       }
1074     }
1075   }
1076
1077   // Depends on Windows driver versioning. We don't pass a GfxDriverInfo object
1078   // back to the Windows handler, so we must handle this here.
1079   if (status == FEATURE_BLOCKED_DRIVER_VERSION) {
1080     if (info[i].mSuggestedVersion) {
1081       aSuggestedVersion.AppendPrintf("%s", info[i].mSuggestedVersion);
1082     } else if (info[i].mComparisonOp == DRIVER_LESS_THAN &&
1083                info[i].mDriverVersion != GfxDriverInfo::allDriverVersions) {
1084       aSuggestedVersion.AppendPrintf(
1085           "%lld.%lld.%lld.%lld",
1086           (info[i].mDriverVersion & 0xffff000000000000) >> 48,
1087           (info[i].mDriverVersion & 0x0000ffff00000000) >> 32,
1088           (info[i].mDriverVersion & 0x00000000ffff0000) >> 16,
1089           (info[i].mDriverVersion & 0x000000000000ffff));
1090     }
1091   }
1092 #endif
1093
1094   return status;
1095 }
1096
1097 void GfxInfoBase::SetFeatureStatus(nsTArray<gfx::GfxInfoFeatureStatus>&& aFS) {
1098   MOZ_ASSERT(!sFeatureStatus);
1099   InitFeatureStatus(new nsTArray<gfx::GfxInfoFeatureStatus>(std::move(aFS)));
1100 }
1101
1102 bool GfxInfoBase::DoesDesktopEnvironmentMatch(
1103     const nsAString& aBlocklistDesktop, const nsAString& aDesktopEnv) {
1104   return aBlocklistDesktop.Equals(aDesktopEnv,
1105                                   nsCaseInsensitiveStringComparator) ||
1106          aBlocklistDesktop.Equals(
1107              GfxDriverInfo::GetDesktopEnvironment(DesktopEnvironment::All),
1108              nsCaseInsensitiveStringComparator);
1109 }
1110
1111 bool GfxInfoBase::DoesWindowProtocolMatch(
1112     const nsAString& aBlocklistWindowProtocol,
1113     const nsAString& aWindowProtocol) {
1114   return aBlocklistWindowProtocol.Equals(aWindowProtocol,
1115                                          nsCaseInsensitiveStringComparator) ||
1116          aBlocklistWindowProtocol.Equals(
1117              GfxDriverInfo::GetWindowProtocol(WindowProtocol::All),
1118              nsCaseInsensitiveStringComparator);
1119 }
1120
1121 bool GfxInfoBase::DoesVendorMatch(const nsAString& aBlocklistVendor,
1122                                   const nsAString& aAdapterVendor) {
1123   return aBlocklistVendor.Equals(aAdapterVendor,
1124                                  nsCaseInsensitiveStringComparator) ||
1125          aBlocklistVendor.Equals(
1126              GfxDriverInfo::GetDeviceVendor(DeviceVendor::All),
1127              nsCaseInsensitiveStringComparator);
1128 }
1129
1130 bool GfxInfoBase::DoesDriverVendorMatch(const nsAString& aBlocklistVendor,
1131                                         const nsAString& aDriverVendor) {
1132   return aBlocklistVendor.Equals(aDriverVendor,
1133                                  nsCaseInsensitiveStringComparator) ||
1134          aBlocklistVendor.Equals(
1135              GfxDriverInfo::GetDriverVendor(DriverVendor::All),
1136              nsCaseInsensitiveStringComparator);
1137 }
1138
1139 bool GfxInfoBase::IsFeatureAllowlisted(int32_t aFeature) const {
1140   return aFeature == nsIGfxInfo::FEATURE_WEBRENDER;
1141 }
1142
1143 nsresult GfxInfoBase::GetFeatureStatusImpl(
1144     int32_t aFeature, int32_t* aStatus, nsAString& aSuggestedVersion,
1145     const nsTArray<GfxDriverInfo>& aDriverInfo, nsACString& aFailureId,
1146     OperatingSystem* aOS /* = nullptr */) {
1147   if (aFeature <= 0) {
1148     gfxWarning() << "Invalid feature <= 0";
1149     return NS_OK;
1150   }
1151
1152   if (*aStatus != nsIGfxInfo::FEATURE_STATUS_UNKNOWN) {
1153     // Terminate now with the status determined by the derived type (OS-specific
1154     // code).
1155     return NS_OK;
1156   }
1157
1158   if (sShutdownOccurred) {
1159     // This is futile; we've already commenced shutdown and our blocklists have
1160     // been deleted. We may want to look into resurrecting the blocklist instead
1161     // but for now, just don't even go there.
1162     return NS_OK;
1163   }
1164
1165   // Ensure any additional initialization required is complete.
1166   GetData();
1167
1168   // If an operating system was provided by the derived GetFeatureStatusImpl,
1169   // grab it here. Otherwise, the OS is unknown.
1170   OperatingSystem os = (aOS ? *aOS : OperatingSystem::Unknown);
1171
1172   nsAutoString adapterVendorID;
1173   nsAutoString adapterDeviceID;
1174   nsAutoString adapterDriverVersionString;
1175   if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) ||
1176       NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) ||
1177       NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString))) {
1178     aFailureId = "FEATURE_FAILURE_CANT_RESOLVE_ADAPTER";
1179     *aStatus = FEATURE_BLOCKED_DEVICE;
1180     return NS_OK;
1181   }
1182
1183   // Check if the device is blocked from the downloaded blocklist. If not, check
1184   // the static list after that. This order is used so that we can later escape
1185   // out of static blocks (i.e. if we were wrong or something was patched, we
1186   // can back out our static block without doing a release).
1187   int32_t status;
1188   if (aDriverInfo.Length()) {
1189     status =
1190         FindBlocklistedDeviceInList(aDriverInfo, aSuggestedVersion, aFeature,
1191                                     aFailureId, os, /* aForAllowing */ false);
1192   } else {
1193     if (!sDriverInfo) {
1194       sDriverInfo = new nsTArray<GfxDriverInfo>();
1195     }
1196     status = FindBlocklistedDeviceInList(GetGfxDriverInfo(), aSuggestedVersion,
1197                                          aFeature, aFailureId, os,
1198                                          /* aForAllowing */ false);
1199   }
1200
1201   if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN) {
1202     if (IsFeatureAllowlisted(aFeature)) {
1203       // This feature is actually using the allowlist; that means after we pass
1204       // the blocklist to prevent us explicitly from getting the feature, we now
1205       // need to check the allowlist to ensure we are allowed to get it in the
1206       // first place.
1207       if (aDriverInfo.Length()) {
1208         status = FindBlocklistedDeviceInList(aDriverInfo, aSuggestedVersion,
1209                                              aFeature, aFailureId, os,
1210                                              /* aForAllowing */ true);
1211       } else {
1212         status = FindBlocklistedDeviceInList(
1213             GetGfxDriverInfo(), aSuggestedVersion, aFeature, aFailureId, os,
1214             /* aForAllowing */ true);
1215       }
1216
1217       if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN) {
1218         status = nsIGfxInfo::FEATURE_DENIED;
1219       }
1220     } else {
1221       // It's now done being processed. It's safe to set the status to
1222       // STATUS_OK.
1223       status = nsIGfxInfo::FEATURE_STATUS_OK;
1224     }
1225   }
1226
1227   *aStatus = status;
1228   return NS_OK;
1229 }
1230
1231 NS_IMETHODIMP
1232 GfxInfoBase::GetFeatureSuggestedDriverVersion(int32_t aFeature,
1233                                               nsAString& aVersion) {
1234   nsCString version;
1235   if (GetPrefValueForDriverVersion(version)) {
1236     aVersion = NS_ConvertASCIItoUTF16(version);
1237     return NS_OK;
1238   }
1239
1240   int32_t status;
1241   nsCString discardFailureId;
1242   nsTArray<GfxDriverInfo> driverInfo;
1243   return GetFeatureStatusImpl(aFeature, &status, aVersion, driverInfo,
1244                               discardFailureId);
1245 }
1246
1247 void GfxInfoBase::EvaluateDownloadedBlocklist(
1248     nsTArray<GfxDriverInfo>& aDriverInfo) {
1249   int32_t features[] = {nsIGfxInfo::FEATURE_DIRECT2D,
1250                         nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS,
1251                         nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS,
1252                         nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS,
1253                         nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS,
1254                         nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE,
1255                         nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING,
1256                         nsIGfxInfo::FEATURE_OPENGL_LAYERS,
1257                         nsIGfxInfo::FEATURE_WEBGL_OPENGL,
1258                         nsIGfxInfo::FEATURE_WEBGL_ANGLE,
1259                         nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE,
1260                         nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE,
1261                         nsIGfxInfo::FEATURE_WEBGL_MSAA,
1262                         nsIGfxInfo::FEATURE_STAGEFRIGHT,
1263                         nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_H264,
1264                         nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION,
1265                         nsIGfxInfo::FEATURE_VP8_HW_DECODE,
1266                         nsIGfxInfo::FEATURE_VP9_HW_DECODE,
1267                         nsIGfxInfo::FEATURE_DX_INTEROP2,
1268                         nsIGfxInfo::FEATURE_GPU_PROCESS,
1269                         nsIGfxInfo::FEATURE_WEBGL2,
1270                         nsIGfxInfo::FEATURE_ADVANCED_LAYERS,
1271                         nsIGfxInfo::FEATURE_D3D11_KEYED_MUTEX,
1272                         nsIGfxInfo::FEATURE_WEBRENDER,
1273                         nsIGfxInfo::FEATURE_WEBRENDER_COMPOSITOR,
1274                         nsIGfxInfo::FEATURE_DX_NV12,
1275                         nsIGfxInfo::FEATURE_DX_P010,
1276                         nsIGfxInfo::FEATURE_DX_P016,
1277                         nsIGfxInfo::FEATURE_GL_SWIZZLE,
1278                         0};
1279
1280   // For every feature we know about, we evaluate whether this blocklist has a
1281   // non-STATUS_OK status. If it does, we set the pref we evaluate in
1282   // GetFeatureStatus above, so we don't need to hold on to this blocklist
1283   // anywhere permanent.
1284   int i = 0;
1285   while (features[i]) {
1286     int32_t status;
1287     nsCString failureId;
1288     nsAutoString suggestedVersion;
1289     if (NS_SUCCEEDED(GetFeatureStatusImpl(
1290             features[i], &status, suggestedVersion, aDriverInfo, failureId))) {
1291       switch (status) {
1292         default:
1293         case nsIGfxInfo::FEATURE_STATUS_OK:
1294           RemovePrefForFeature(features[i]);
1295           break;
1296
1297         case nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION:
1298           if (!suggestedVersion.IsEmpty()) {
1299             SetPrefValueForDriverVersion(suggestedVersion);
1300           } else {
1301             RemovePrefForDriverVersion();
1302           }
1303           [[fallthrough]];
1304
1305         case nsIGfxInfo::FEATURE_BLOCKED_MISMATCHED_VERSION:
1306         case nsIGfxInfo::FEATURE_BLOCKED_DEVICE:
1307         case nsIGfxInfo::FEATURE_DISCOURAGED:
1308         case nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION:
1309           SetPrefValueForFeature(features[i], status, failureId);
1310           break;
1311       }
1312     }
1313
1314     ++i;
1315   }
1316 }
1317
1318 NS_IMETHODIMP_(void)
1319 GfxInfoBase::LogFailure(const nsACString& failure) {
1320   // gfxCriticalError has a mutex lock of its own, so we may not actually
1321   // need this lock. ::GetFailures() accesses the data but the LogForwarder
1322   // will not return the copy of the logs unless it can get the same lock
1323   // that gfxCriticalError uses.  Still, that is so much of an implementation
1324   // detail that it's nicer to just add an extra lock here and in
1325   // ::GetFailures()
1326   MutexAutoLock lock(mMutex);
1327
1328   // By default, gfxCriticalError asserts; make it not assert in this case.
1329   gfxCriticalError(CriticalLog::DefaultOptions(false))
1330       << "(LF) " << failure.BeginReading();
1331 }
1332
1333 NS_IMETHODIMP GfxInfoBase::GetFailures(nsTArray<int32_t>& indices,
1334                                        nsTArray<nsCString>& failures) {
1335   MutexAutoLock lock(mMutex);
1336
1337   LogForwarder* logForwarder = Factory::GetLogForwarder();
1338   if (!logForwarder) {
1339     return NS_ERROR_UNEXPECTED;
1340   }
1341
1342   // There are two string copies in this method, starting with this one. We are
1343   // assuming this is not a big deal, as the size of the array should be small
1344   // and the strings in it should be small as well (the error messages in the
1345   // code.)  The second copy happens with the AppendElement() calls.
1346   // Technically, we don't need the mutex lock after the StringVectorCopy()
1347   // call.
1348   LoggingRecord loggedStrings = logForwarder->LoggingRecordCopy();
1349   LoggingRecord::const_iterator it;
1350   for (it = loggedStrings.begin(); it != loggedStrings.end(); ++it) {
1351     failures.AppendElement(
1352         nsDependentCSubstring(Get<1>(*it).c_str(), Get<1>(*it).size()));
1353     indices.AppendElement(Get<0>(*it));
1354   }
1355
1356   return NS_OK;
1357 }
1358
1359 nsTArray<GfxInfoCollectorBase*>* sCollectors;
1360
1361 static void InitCollectors() {
1362   if (!sCollectors) sCollectors = new nsTArray<GfxInfoCollectorBase*>;
1363 }
1364
1365 nsresult GfxInfoBase::GetInfo(JSContext* aCx,
1366                               JS::MutableHandle<JS::Value> aResult) {
1367   InitCollectors();
1368   InfoObject obj(aCx);
1369
1370   for (uint32_t i = 0; i < sCollectors->Length(); i++) {
1371     (*sCollectors)[i]->GetInfo(obj);
1372   }
1373
1374   // Some example property definitions
1375   // obj.DefineProperty("wordCacheSize", gfxTextRunWordCache::Count());
1376   // obj.DefineProperty("renderer", mRendererIDsString);
1377   // obj.DefineProperty("five", 5);
1378
1379   if (!obj.mOk) {
1380     return NS_ERROR_FAILURE;
1381   }
1382
1383   aResult.setObject(*obj.mObj);
1384   return NS_OK;
1385 }
1386
1387 nsAutoCString gBaseAppVersion;
1388
1389 const nsCString& GfxInfoBase::GetApplicationVersion() {
1390   static bool versionInitialized = false;
1391   if (!versionInitialized) {
1392     // If we fail to get the version, we will not try again.
1393     versionInitialized = true;
1394
1395     // Get the version from xpcom/system/nsIXULAppInfo.idl
1396     nsCOMPtr<nsIXULAppInfo> app = do_GetService("@mozilla.org/xre/app-info;1");
1397     if (app) {
1398       app->GetVersion(gBaseAppVersion);
1399     }
1400   }
1401   return gBaseAppVersion;
1402 }
1403
1404 void GfxInfoBase::AddCollector(GfxInfoCollectorBase* collector) {
1405   InitCollectors();
1406   sCollectors->AppendElement(collector);
1407 }
1408
1409 void GfxInfoBase::RemoveCollector(GfxInfoCollectorBase* collector) {
1410   InitCollectors();
1411   for (uint32_t i = 0; i < sCollectors->Length(); i++) {
1412     if ((*sCollectors)[i] == collector) {
1413       sCollectors->RemoveElementAt(i);
1414       break;
1415     }
1416   }
1417   if (sCollectors->IsEmpty()) {
1418     delete sCollectors;
1419     sCollectors = nullptr;
1420   }
1421 }
1422
1423 nsresult GfxInfoBase::FindMonitors(JSContext* aCx, JS::HandleObject aOutArray) {
1424   // If we have no platform specific implementation for detecting monitors, we
1425   // can just get the screen size from gfxPlatform as the best guess.
1426   if (!gfxPlatform::Initialized()) {
1427     return NS_OK;
1428   }
1429
1430   // If the screen size is empty, we are probably in xpcshell.
1431   gfx::IntSize screenSize = gfxPlatform::GetPlatform()->GetScreenSize();
1432
1433   JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1434
1435   JS::Rooted<JS::Value> screenWidth(aCx, JS::Int32Value(screenSize.width));
1436   JS_SetProperty(aCx, obj, "screenWidth", screenWidth);
1437
1438   JS::Rooted<JS::Value> screenHeight(aCx, JS::Int32Value(screenSize.height));
1439   JS_SetProperty(aCx, obj, "screenHeight", screenHeight);
1440
1441   JS::Rooted<JS::Value> element(aCx, JS::ObjectValue(*obj));
1442   JS_SetElement(aCx, aOutArray, 0, element);
1443
1444   return NS_OK;
1445 }
1446
1447 NS_IMETHODIMP
1448 GfxInfoBase::GetMonitors(JSContext* aCx, JS::MutableHandleValue aResult) {
1449   JS::Rooted<JSObject*> array(aCx, JS::NewArrayObject(aCx, 0));
1450
1451   nsresult rv = FindMonitors(aCx, array);
1452   if (NS_FAILED(rv)) {
1453     return rv;
1454   }
1455
1456   aResult.setObject(*array);
1457   return NS_OK;
1458 }
1459
1460 static inline bool SetJSPropertyString(JSContext* aCx,
1461                                        JS::Handle<JSObject*> aObj,
1462                                        const char* aProp, const char* aString) {
1463   JS::Rooted<JSString*> str(aCx, JS_NewStringCopyZ(aCx, aString));
1464   if (!str) {
1465     return false;
1466   }
1467
1468   JS::Rooted<JS::Value> val(aCx, JS::StringValue(str));
1469   return JS_SetProperty(aCx, aObj, aProp, val);
1470 }
1471
1472 template <typename T>
1473 static inline bool AppendJSElement(JSContext* aCx, JS::Handle<JSObject*> aObj,
1474                                    const T& aValue) {
1475   uint32_t index;
1476   if (!JS::GetArrayLength(aCx, aObj, &index)) {
1477     return false;
1478   }
1479   return JS_SetElement(aCx, aObj, index, aValue);
1480 }
1481
1482 nsresult GfxInfoBase::GetFeatures(JSContext* aCx,
1483                                   JS::MutableHandle<JS::Value> aOut) {
1484   JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1485   if (!obj) {
1486     return NS_ERROR_OUT_OF_MEMORY;
1487   }
1488   aOut.setObject(*obj);
1489
1490   layers::LayersBackend backend =
1491       gfxPlatform::Initialized()
1492           ? gfxPlatform::GetPlatform()->GetCompositorBackend()
1493           : layers::LayersBackend::LAYERS_NONE;
1494   const char* backendName = layers::GetLayersBackendName(backend);
1495   SetJSPropertyString(aCx, obj, "compositor", backendName);
1496
1497   // If graphics isn't initialized yet, just stop now.
1498   if (!gfxPlatform::Initialized()) {
1499     return NS_OK;
1500   }
1501
1502   DescribeFeatures(aCx, obj);
1503   return NS_OK;
1504 }
1505
1506 nsresult GfxInfoBase::GetFeatureLog(JSContext* aCx,
1507                                     JS::MutableHandle<JS::Value> aOut) {
1508   JS::Rooted<JSObject*> containerObj(aCx, JS_NewPlainObject(aCx));
1509   if (!containerObj) {
1510     return NS_ERROR_OUT_OF_MEMORY;
1511   }
1512   aOut.setObject(*containerObj);
1513
1514   JS::Rooted<JSObject*> featureArray(aCx, JS::NewArrayObject(aCx, 0));
1515   if (!featureArray) {
1516     return NS_ERROR_OUT_OF_MEMORY;
1517   }
1518
1519   // Collect features.
1520   gfxConfig::ForEachFeature([&](const char* aName, const char* aDescription,
1521                                 FeatureState& aFeature) -> void {
1522     JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1523     if (!obj) {
1524       return;
1525     }
1526     if (!SetJSPropertyString(aCx, obj, "name", aName) ||
1527         !SetJSPropertyString(aCx, obj, "description", aDescription) ||
1528         !SetJSPropertyString(aCx, obj, "status",
1529                              FeatureStatusToString(aFeature.GetValue()))) {
1530       return;
1531     }
1532
1533     JS::Rooted<JS::Value> log(aCx);
1534     if (!BuildFeatureStateLog(aCx, aFeature, &log)) {
1535       return;
1536     }
1537     if (!JS_SetProperty(aCx, obj, "log", log)) {
1538       return;
1539     }
1540
1541     if (!AppendJSElement(aCx, featureArray, obj)) {
1542       return;
1543     }
1544   });
1545
1546   JS::Rooted<JSObject*> fallbackArray(aCx, JS::NewArrayObject(aCx, 0));
1547   if (!fallbackArray) {
1548     return NS_ERROR_OUT_OF_MEMORY;
1549   }
1550
1551   // Collect fallbacks.
1552   gfxConfig::ForEachFallback(
1553       [&](const char* aName, const char* aMessage) -> void {
1554         JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1555         if (!obj) {
1556           return;
1557         }
1558
1559         if (!SetJSPropertyString(aCx, obj, "name", aName) ||
1560             !SetJSPropertyString(aCx, obj, "message", aMessage)) {
1561           return;
1562         }
1563
1564         if (!AppendJSElement(aCx, fallbackArray, obj)) {
1565           return;
1566         }
1567       });
1568
1569   JS::Rooted<JS::Value> val(aCx);
1570
1571   val = JS::ObjectValue(*featureArray);
1572   JS_SetProperty(aCx, containerObj, "features", val);
1573
1574   val = JS::ObjectValue(*fallbackArray);
1575   JS_SetProperty(aCx, containerObj, "fallbacks", val);
1576
1577   return NS_OK;
1578 }
1579
1580 bool GfxInfoBase::BuildFeatureStateLog(JSContext* aCx,
1581                                        const FeatureState& aFeature,
1582                                        JS::MutableHandle<JS::Value> aOut) {
1583   JS::Rooted<JSObject*> log(aCx, JS::NewArrayObject(aCx, 0));
1584   if (!log) {
1585     return false;
1586   }
1587   aOut.setObject(*log);
1588
1589   aFeature.ForEachStatusChange([&](const char* aType, FeatureStatus aStatus,
1590                                    const char* aMessage) -> void {
1591     JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1592     if (!obj) {
1593       return;
1594     }
1595
1596     if (!SetJSPropertyString(aCx, obj, "type", aType) ||
1597         !SetJSPropertyString(aCx, obj, "status",
1598                              FeatureStatusToString(aStatus)) ||
1599         (aMessage && !SetJSPropertyString(aCx, obj, "message", aMessage))) {
1600       return;
1601     }
1602
1603     if (!AppendJSElement(aCx, log, obj)) {
1604       return;
1605     }
1606   });
1607
1608   return true;
1609 }
1610
1611 void GfxInfoBase::DescribeFeatures(JSContext* aCx, JS::Handle<JSObject*> aObj) {
1612   JS::Rooted<JSObject*> obj(aCx);
1613
1614   gfx::FeatureState& hwCompositing =
1615       gfxConfig::GetFeature(gfx::Feature::HW_COMPOSITING);
1616   InitFeatureObject(aCx, aObj, "hwCompositing", hwCompositing, &obj);
1617
1618   gfx::FeatureState& gpuProcess =
1619       gfxConfig::GetFeature(gfx::Feature::GPU_PROCESS);
1620   InitFeatureObject(aCx, aObj, "gpuProcess", gpuProcess, &obj);
1621
1622   gfx::FeatureState& wrQualified =
1623       gfxConfig::GetFeature(gfx::Feature::WEBRENDER_QUALIFIED);
1624   InitFeatureObject(aCx, aObj, "wrQualified", wrQualified, &obj);
1625
1626   gfx::FeatureState& webrender = gfxConfig::GetFeature(gfx::Feature::WEBRENDER);
1627   InitFeatureObject(aCx, aObj, "webrender", webrender, &obj);
1628
1629   gfx::FeatureState& wrCompositor =
1630       gfxConfig::GetFeature(gfx::Feature::WEBRENDER_COMPOSITOR);
1631   InitFeatureObject(aCx, aObj, "wrCompositor", wrCompositor, &obj);
1632
1633   gfx::FeatureState& openglCompositing =
1634       gfxConfig::GetFeature(gfx::Feature::OPENGL_COMPOSITING);
1635   InitFeatureObject(aCx, aObj, "openglCompositing", openglCompositing, &obj);
1636
1637   // Only include AL if the platform attempted to use it.
1638   gfx::FeatureState& advancedLayers =
1639       gfxConfig::GetFeature(gfx::Feature::ADVANCED_LAYERS);
1640   if (advancedLayers.GetValue() != FeatureStatus::Unused) {
1641     InitFeatureObject(aCx, aObj, "advancedLayers", advancedLayers, &obj);
1642
1643     if (gfxConfig::UseFallback(Fallback::NO_CONSTANT_BUFFER_OFFSETTING)) {
1644       JS::Rooted<JS::Value> trueVal(aCx, JS::BooleanValue(true));
1645       JS_SetProperty(aCx, obj, "noConstantBufferOffsetting", trueVal);
1646     }
1647   }
1648 }
1649
1650 bool GfxInfoBase::InitFeatureObject(JSContext* aCx,
1651                                     JS::Handle<JSObject*> aContainer,
1652                                     const char* aName,
1653                                     mozilla::gfx::FeatureState& aFeatureState,
1654                                     JS::MutableHandle<JSObject*> aOutObj) {
1655   JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1656   if (!obj) {
1657     return false;
1658   }
1659
1660   nsCString status;
1661   auto value = aFeatureState.GetValue();
1662   switch (value) {
1663     case FeatureStatus::Blocklisted:
1664     case FeatureStatus::Disabled:
1665     case FeatureStatus::Unavailable:
1666     case FeatureStatus::UnavailableNoAngle:
1667     case FeatureStatus::Blocked:
1668       status.AppendPrintf("%s:%s", FeatureStatusToString(value),
1669                           aFeatureState.GetFailureId().get());
1670       break;
1671     default:
1672       status.Append(FeatureStatusToString(value));
1673       break;
1674   }
1675
1676   JS::Rooted<JSString*> str(aCx, JS_NewStringCopyZ(aCx, status.get()));
1677   JS::Rooted<JS::Value> val(aCx, JS::StringValue(str));
1678   JS_SetProperty(aCx, obj, "status", val);
1679
1680   // Add the feature object to the container.
1681   {
1682     JS::Rooted<JS::Value> val(aCx, JS::ObjectValue(*obj));
1683     JS_SetProperty(aCx, aContainer, aName, val);
1684   }
1685
1686   aOutObj.set(obj);
1687   return true;
1688 }
1689
1690 nsresult GfxInfoBase::GetActiveCrashGuards(JSContext* aCx,
1691                                            JS::MutableHandle<JS::Value> aOut) {
1692   JS::Rooted<JSObject*> array(aCx, JS::NewArrayObject(aCx, 0));
1693   if (!array) {
1694     return NS_ERROR_OUT_OF_MEMORY;
1695   }
1696   aOut.setObject(*array);
1697
1698   DriverCrashGuard::ForEachActiveCrashGuard(
1699       [&](const char* aName, const char* aPrefName) -> void {
1700         JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
1701         if (!obj) {
1702           return;
1703         }
1704         if (!SetJSPropertyString(aCx, obj, "type", aName)) {
1705           return;
1706         }
1707         if (!SetJSPropertyString(aCx, obj, "prefName", aPrefName)) {
1708           return;
1709         }
1710         if (!AppendJSElement(aCx, array, obj)) {
1711           return;
1712         }
1713       });
1714
1715   return NS_OK;
1716 }
1717
1718 NS_IMETHODIMP
1719 GfxInfoBase::GetWebRenderEnabled(bool* aWebRenderEnabled) {
1720   *aWebRenderEnabled = gfxVars::UseWebRender();
1721   return NS_OK;
1722 }
1723
1724 NS_IMETHODIMP
1725 GfxInfoBase::GetUsesTiling(bool* aUsesTiling) {
1726   *aUsesTiling = gfxPlatform::GetPlatform()->UsesTiling();
1727   return NS_OK;
1728 }
1729
1730 NS_IMETHODIMP
1731 GfxInfoBase::GetContentUsesTiling(bool* aUsesTiling) {
1732   *aUsesTiling = gfxPlatform::GetPlatform()->ContentUsesTiling();
1733   return NS_OK;
1734 }
1735
1736 NS_IMETHODIMP
1737 GfxInfoBase::GetOffMainThreadPaintEnabled(bool* aOffMainThreadPaintEnabled) {
1738   *aOffMainThreadPaintEnabled = gfxConfig::IsEnabled(gfx::Feature::OMTP);
1739   return NS_OK;
1740 }
1741
1742 NS_IMETHODIMP
1743 GfxInfoBase::GetOffMainThreadPaintWorkerCount(
1744     int32_t* aOffMainThreadPaintWorkerCount) {
1745   if (gfxConfig::IsEnabled(gfx::Feature::OMTP)) {
1746     *aOffMainThreadPaintWorkerCount =
1747         layers::PaintThread::CalculatePaintWorkerCount();
1748   } else {
1749     *aOffMainThreadPaintWorkerCount = 0;
1750   }
1751   return NS_OK;
1752 }
1753
1754 NS_IMETHODIMP
1755 GfxInfoBase::GetTargetFrameRate(uint32_t* aTargetFrameRate) {
1756   *aTargetFrameRate = gfxPlatform::TargetFrameRate();
1757   return NS_OK;
1758 }
1759
1760 NS_IMETHODIMP
1761 GfxInfoBase::GetIsHeadless(bool* aIsHeadless) {
1762   *aIsHeadless = gfxPlatform::IsHeadless();
1763   return NS_OK;
1764 }
1765
1766 NS_IMETHODIMP
1767 GfxInfoBase::GetContentBackend(nsAString& aContentBackend) {
1768   BackendType backend = gfxPlatform::GetPlatform()->GetDefaultContentBackend();
1769   nsString outStr;
1770
1771   switch (backend) {
1772     case BackendType::DIRECT2D1_1: {
1773       outStr.AppendPrintf("Direct2D 1.1");
1774       break;
1775     }
1776     case BackendType::SKIA: {
1777       outStr.AppendPrintf("Skia");
1778       break;
1779     }
1780     case BackendType::CAIRO: {
1781       outStr.AppendPrintf("Cairo");
1782       break;
1783     }
1784     default:
1785       return NS_ERROR_FAILURE;
1786   }
1787
1788   aContentBackend.Assign(outStr);
1789   return NS_OK;
1790 }
1791
1792 NS_IMETHODIMP
1793 GfxInfoBase::GetUsingGPUProcess(bool* aOutValue) {
1794   GPUProcessManager* gpu = GPUProcessManager::Get();
1795   if (!gpu) {
1796     // Not supported in content processes.
1797     return NS_ERROR_FAILURE;
1798   }
1799
1800   *aOutValue = !!gpu->GetGPUChild();
1801   return NS_OK;
1802 }
1803
1804 NS_IMETHODIMP
1805 GfxInfoBase::ControlGPUProcessForXPCShell(bool aEnable, bool* _retval) {
1806   gfxPlatform::GetPlatform();
1807
1808   GPUProcessManager* gpm = GPUProcessManager::Get();
1809   if (aEnable) {
1810     if (!gfxConfig::IsEnabled(gfx::Feature::GPU_PROCESS)) {
1811       gfxConfig::UserForceEnable(gfx::Feature::GPU_PROCESS, "xpcshell-test");
1812     }
1813     gpm->LaunchGPUProcess();
1814     gpm->EnsureGPUReady();
1815   } else {
1816     gfxConfig::UserDisable(gfx::Feature::GPU_PROCESS, "xpcshell-test");
1817     gpm->KillProcess();
1818   }
1819
1820   *_retval = true;
1821   return NS_OK;
1822 }
1823
1824 GfxInfoCollectorBase::GfxInfoCollectorBase() {
1825   GfxInfoBase::AddCollector(this);
1826 }
1827
1828 GfxInfoCollectorBase::~GfxInfoCollectorBase() {
1829   GfxInfoBase::RemoveCollector(this);
1830 }