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