tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TestConfigManager.cpp (33527B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 #include "gtest/gtest.h"
      7 
      8 #include "gfxFeature.h"
      9 #include "mozilla/gfx/gfxConfigManager.h"
     10 #include "nsIGfxInfo.h"
     11 
     12 using namespace mozilla;
     13 using namespace mozilla::gfx;
     14 
     15 namespace mozilla {
     16 namespace gfx {
     17 
     18 class MockGfxInfo final : public nsIGfxInfo {
     19 public:
     20  NS_DECL_THREADSAFE_ISUPPORTS
     21 
     22  int32_t mStatusWr = nsIGfxInfo::FEATURE_STATUS_OK;
     23  int32_t mStatusWrCompositor = nsIGfxInfo::FEATURE_STATUS_OK;
     24  int32_t mStatusWrShaderCache = nsIGfxInfo::FEATURE_STATUS_OK;
     25  int32_t mStatusWrOptimizedShaders = nsIGfxInfo::FEATURE_STATUS_OK;
     26  int32_t mStatusWrPartialPresent = nsIGfxInfo::FEATURE_STATUS_OK;
     27  int32_t mStatusWrScissoredCacheClears = nsIGfxInfo::FEATURE_STATUS_OK;
     28  int32_t mStatusWrDComp = nsIGfxInfo::FEATURE_STATUS_OK;
     29  int32_t mStatusGLNorm16Textures = nsIGfxInfo::FEATURE_STATUS_OK;
     30  Maybe<bool> mHasBattery = Some(false);
     31  const char* mVendorId = "0x10de";
     32  const char* mDeviceId = "";
     33 
     34  // Default allows WebRender + compositor, and is desktop NVIDIA.
     35  MockGfxInfo() = default;
     36 
     37  NS_IMETHOD GetFeatureStatus(int32_t aFeature, nsACString& aFailureId,
     38                              int32_t* _retval) override {
     39    switch (aFeature) {
     40      case nsIGfxInfo::FEATURE_WEBRENDER:
     41        *_retval = mStatusWr;
     42        break;
     43      case nsIGfxInfo::FEATURE_WEBRENDER_COMPOSITOR:
     44        *_retval = mStatusWrCompositor;
     45        break;
     46      case nsIGfxInfo::FEATURE_WEBRENDER_SHADER_CACHE:
     47        *_retval = mStatusWrShaderCache;
     48        break;
     49      case nsIGfxInfo::FEATURE_WEBRENDER_OPTIMIZED_SHADERS:
     50        *_retval = mStatusWrOptimizedShaders;
     51        break;
     52      case nsIGfxInfo::FEATURE_WEBRENDER_PARTIAL_PRESENT:
     53        *_retval = mStatusWrPartialPresent;
     54        break;
     55      case nsIGfxInfo::FEATURE_WEBRENDER_SCISSORED_CACHE_CLEARS:
     56        *_retval = mStatusWrScissoredCacheClears;
     57        break;
     58      case nsIGfxInfo::FEATURE_WEBRENDER_DCOMP:
     59        *_retval = mStatusWrDComp;
     60        break;
     61      case nsIGfxInfo::FEATURE_GL_NORM16_TEXTURES:
     62        *_retval = mStatusGLNorm16Textures;
     63        break;
     64      default:
     65        return NS_ERROR_NOT_IMPLEMENTED;
     66    }
     67    return NS_OK;
     68  }
     69 
     70  NS_IMETHOD GetHasBattery(bool* aHasBattery) override {
     71    if (mHasBattery.isNothing()) {
     72      return NS_ERROR_NOT_IMPLEMENTED;
     73    }
     74    *aHasBattery = *mHasBattery;
     75    return NS_OK;
     76  }
     77 
     78  NS_IMETHOD GetAdapterVendorID(nsAString& aAdapterVendorID) override {
     79    if (!mVendorId) {
     80      return NS_ERROR_NOT_IMPLEMENTED;
     81    }
     82    aAdapterVendorID.AssignASCII(mVendorId);
     83    return NS_OK;
     84  }
     85 
     86  NS_IMETHOD GetAdapterDeviceID(nsAString& aAdapterDeviceID) override {
     87    if (!mDeviceId) {
     88      return NS_ERROR_NOT_IMPLEMENTED;
     89    }
     90    aAdapterDeviceID.AssignASCII(mDeviceId);
     91    return NS_OK;
     92  }
     93 
     94  NS_IMETHOD GetTextScaleFactor(float* aTextScaleFactor) override {
     95    return NS_ERROR_NOT_IMPLEMENTED;
     96  }
     97 
     98  NS_IMETHODIMP GetEmbeddedInFirefoxReality(
     99      bool* aEmbeddedInFirefoxReality) override {
    100    return NS_ERROR_NOT_IMPLEMENTED;
    101  }
    102 
    103  NS_IMETHOD GetAzureCanvasBackend(nsAString& aBackend) override {
    104    return NS_ERROR_NOT_IMPLEMENTED;
    105  }
    106 
    107  NS_IMETHOD GetAzureContentBackend(nsAString& aBackend) override {
    108    return NS_ERROR_NOT_IMPLEMENTED;
    109  }
    110 
    111  // The following methods we don't need for testing gfxConfigManager.
    112  NS_IMETHOD GetFeatureStatusStr(const nsAString& aFeature,
    113                                 nsACString& aFailureId,
    114                                 nsAString& _retval) override {
    115    return NS_ERROR_NOT_IMPLEMENTED;
    116  }
    117 
    118  NS_IMETHOD GetFeatureSuggestedDriverVersionStr(const nsAString& aFeature,
    119                                                 nsAString& _retval) override {
    120    return NS_ERROR_NOT_IMPLEMENTED;
    121  }
    122 
    123  NS_IMETHOD GetFeatureSuggestedDriverVersion(int32_t aFeature,
    124                                              nsAString& _retval) override {
    125    return NS_ERROR_NOT_IMPLEMENTED;
    126  }
    127 
    128  NS_IMETHOD GetMonitors(JSContext* cx,
    129                         JS::MutableHandle<JS::Value> _retval) override {
    130    return NS_ERROR_NOT_IMPLEMENTED;
    131  }
    132  NS_IMETHOD GetFailures(nsTArray<int32_t>& indices,
    133                         nsTArray<nsCString>& failures) override {
    134    return NS_ERROR_NOT_IMPLEMENTED;
    135  }
    136  NS_IMETHOD_(void) LogFailure(const nsACString& failure) override {}
    137  NS_IMETHOD GetInfo(JSContext*, JS::MutableHandle<JS::Value>) override {
    138    return NS_ERROR_NOT_IMPLEMENTED;
    139  }
    140  NS_IMETHOD GetFeatures(JSContext*, JS::MutableHandle<JS::Value>) override {
    141    return NS_ERROR_NOT_IMPLEMENTED;
    142  }
    143  NS_IMETHOD GetFeatureLog(JSContext*, JS::MutableHandle<JS::Value>) override {
    144    return NS_ERROR_NOT_IMPLEMENTED;
    145  }
    146  NS_IMETHOD GetActiveCrashGuards(JSContext*,
    147                                  JS::MutableHandle<JS::Value>) override {
    148    return NS_ERROR_NOT_IMPLEMENTED;
    149  }
    150  NS_IMETHOD GetFontVisibilityDetermination(
    151      nsIGfxInfo::FontVisibilityDeviceDetermination*
    152          aFontVisibilityDetermination) override {
    153    return NS_ERROR_NOT_IMPLEMENTED;
    154  }
    155  NS_IMETHOD GetFontVisibilityDeterminationStr(
    156      nsAString& aFontVisibilityDeterminationStr) override {
    157    return NS_ERROR_NOT_IMPLEMENTED;
    158  }
    159  NS_IMETHOD GetContentBackend(nsAString& aContentBackend) override {
    160    return NS_ERROR_NOT_IMPLEMENTED;
    161  }
    162  NS_IMETHOD GetUsingGPUProcess(bool* aOutValue) override {
    163    return NS_ERROR_NOT_IMPLEMENTED;
    164  }
    165  NS_IMETHOD GetUsingAcceleratedCanvas(bool* aOutValue) override {
    166    return NS_ERROR_NOT_IMPLEMENTED;
    167  }
    168  NS_IMETHOD GetIsHeadless(bool* aIsHeadless) override {
    169    return NS_ERROR_NOT_IMPLEMENTED;
    170  }
    171  NS_IMETHOD GetTargetFrameRate(uint32_t* aTargetFrameRate) override {
    172    return NS_ERROR_NOT_IMPLEMENTED;
    173  }
    174  NS_IMETHOD GetCodecSupportInfo(nsACString& aCodecSupportInfo) override {
    175    return NS_ERROR_NOT_IMPLEMENTED;
    176  }
    177  NS_IMETHOD_(void)
    178  SetCodecSupportInfo(const nsACString& aCodecSupportInfo) override {}
    179  NS_IMETHOD GetDWriteEnabled(bool* aDWriteEnabled) override {
    180    return NS_ERROR_NOT_IMPLEMENTED;
    181  }
    182  NS_IMETHOD GetDWriteVersion(nsAString& aDwriteVersion) override {
    183    return NS_ERROR_NOT_IMPLEMENTED;
    184  }
    185  NS_IMETHOD GetCleartypeParameters(nsAString& aCleartypeParams) override {
    186    return NS_ERROR_NOT_IMPLEMENTED;
    187  }
    188  NS_IMETHOD GetWindowProtocol(nsAString& aWindowProtocol) override {
    189    return NS_ERROR_NOT_IMPLEMENTED;
    190  }
    191  NS_IMETHOD GetTestType(nsAString& aTestType) override {
    192    return NS_ERROR_NOT_IMPLEMENTED;
    193  }
    194  NS_IMETHOD GetAdapterDescription(nsAString& aAdapterDescription) override {
    195    return NS_ERROR_NOT_IMPLEMENTED;
    196  }
    197  NS_IMETHOD GetAdapterDriver(nsAString& aAdapterDriver) override {
    198    return NS_ERROR_NOT_IMPLEMENTED;
    199  }
    200  NS_IMETHOD GetAdapterSubsysID(nsAString& aAdapterSubsysID) override {
    201    return NS_ERROR_NOT_IMPLEMENTED;
    202  }
    203  NS_IMETHOD GetAdapterRAM(uint32_t* aAdapterRAM) override {
    204    return NS_ERROR_NOT_IMPLEMENTED;
    205  }
    206  NS_IMETHOD GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) override {
    207    return NS_ERROR_NOT_IMPLEMENTED;
    208  }
    209  NS_IMETHOD GetAdapterDriverVersion(
    210      nsAString& aAdapterDriverVersion) override {
    211    return NS_ERROR_NOT_IMPLEMENTED;
    212  }
    213  NS_IMETHOD GetAdapterDriverDate(nsAString& aAdapterDriverDate) override {
    214    return NS_ERROR_NOT_IMPLEMENTED;
    215  }
    216  NS_IMETHOD GetAdapterDescription2(nsAString& aAdapterDescription) override {
    217    return NS_ERROR_NOT_IMPLEMENTED;
    218  }
    219  NS_IMETHOD GetAdapterDriver2(nsAString& aAdapterDriver) override {
    220    return NS_ERROR_NOT_IMPLEMENTED;
    221  }
    222  NS_IMETHOD GetAdapterVendorID2(nsAString& aAdapterVendorID) override {
    223    return NS_ERROR_NOT_IMPLEMENTED;
    224  }
    225  NS_IMETHOD GetAdapterDeviceID2(nsAString& aAdapterDeviceID) override {
    226    return NS_ERROR_NOT_IMPLEMENTED;
    227  }
    228  NS_IMETHOD GetAdapterSubsysID2(nsAString& aAdapterSubsysID) override {
    229    return NS_ERROR_NOT_IMPLEMENTED;
    230  }
    231  NS_IMETHOD GetAdapterRAM2(uint32_t* aAdapterRAM) override {
    232    return NS_ERROR_NOT_IMPLEMENTED;
    233  }
    234  NS_IMETHOD GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) override {
    235    return NS_ERROR_NOT_IMPLEMENTED;
    236  }
    237  NS_IMETHOD GetAdapterDriverVersion2(
    238      nsAString& aAdapterDriverVersion) override {
    239    return NS_ERROR_NOT_IMPLEMENTED;
    240  }
    241  NS_IMETHOD GetAdapterDriverDate2(nsAString& aAdapterDriverDate) override {
    242    return NS_ERROR_NOT_IMPLEMENTED;
    243  }
    244  NS_IMETHOD GetIsGPU2Active(bool* aIsGPU2Active) override {
    245    return NS_ERROR_NOT_IMPLEMENTED;
    246  }
    247  NS_IMETHOD GetDrmRenderDevice(nsACString& aDrmRenderDevice) override {
    248    return NS_ERROR_NOT_IMPLEMENTED;
    249  }
    250  NS_IMETHOD ControlGPUProcessForXPCShell(bool aEnable,
    251                                          bool* _retval) override {
    252    return NS_ERROR_NOT_IMPLEMENTED;
    253  }
    254  NS_IMETHOD KillGPUProcessForTests() override {
    255    return NS_ERROR_NOT_IMPLEMENTED;
    256  }
    257  NS_IMETHOD CrashGPUProcessForTests() override {
    258    return NS_ERROR_NOT_IMPLEMENTED;
    259  }
    260 
    261  NS_IMETHOD_(void) GetData() override {}
    262 
    263 private:
    264  virtual ~MockGfxInfo() = default;
    265 };
    266 
    267 NS_IMPL_ISUPPORTS(MockGfxInfo, nsIGfxInfo)
    268 
    269 class GfxConfigManager : public ::testing::Test, public gfxConfigManager {
    270 public:
    271  GfxConfigManager() {
    272    mFeatureWr = &mFeatures.mWr;
    273    mFeatureWrCompositor = &mFeatures.mWrCompositor;
    274    mFeatureWrAngle = &mFeatures.mWrAngle;
    275    mFeatureWrDComp = &mFeatures.mWrDComp;
    276    mFeatureWrPartial = &mFeatures.mWrPartial;
    277    mFeatureWrShaderCache = &mFeatures.mWrShaderCache;
    278    mFeatureWrOptimizedShaders = &mFeatures.mWrOptimizedShaders;
    279    mFeatureWrScissoredCacheClears = &mFeatures.mWrScissoredCacheClears;
    280    mFeatureHwCompositing = &mFeatures.mHwCompositing;
    281    mFeatureGPUProcess = &mFeatures.mGPUProcess;
    282    mFeatureGLNorm16Textures = &mFeatures.mGLNorm16Textures;
    283  }
    284 
    285  void SetUp() override {
    286    mMockGfxInfo = new MockGfxInfo();
    287    mGfxInfo = mMockGfxInfo;
    288 
    289    mFeatureD3D11HwAngle = &mFeatures.mD3D11HwAngle;
    290    mFeatureD3D11Compositing = &mFeatures.mD3D11Compositing;
    291 
    292    // By default, turn everything on. This effectively assumes we are on
    293    // qualified nightly Windows 10 with DirectComposition support.
    294    mFeatureHwCompositing->EnableByDefault();
    295    mFeatureD3D11HwAngle->EnableByDefault();
    296    mFeatureD3D11Compositing->EnableByDefault();
    297    mFeatureGPUProcess->EnableByDefault();
    298 
    299    mWrCompositorEnabled.emplace(true);
    300    mWrPartialPresent = true;
    301    mWrShaderCache.emplace(true);
    302    mWrOptimizedShaders = true;
    303    mWrForceAngle = true;
    304    mWrDCompWinEnabled = true;
    305    mWrCompositorDCompRequired = true;
    306    mWrScissoredCacheClearsEnabled = true;
    307    ++mHwStretchingSupport.mBoth;
    308    mIsNightly = true;
    309    mIsEarlyBetaOrEarlier = true;
    310  }
    311 
    312  void TearDown() override {
    313    mFeatures.mWr.Reset();
    314    mFeatures.mWrCompositor.Reset();
    315    mFeatures.mWrAngle.Reset();
    316    mFeatures.mWrDComp.Reset();
    317    mFeatures.mWrPartial.Reset();
    318    mFeatures.mWrShaderCache.Reset();
    319    mFeatures.mWrOptimizedShaders.Reset();
    320    mFeatures.mWrScissoredCacheClears.Reset();
    321    mFeatures.mHwCompositing.Reset();
    322    mFeatures.mD3D11HwAngle.Reset();
    323    mFeatures.mD3D11Compositing.Reset();
    324    mFeatures.mGPUProcess.Reset();
    325    mFeatures.mGLNorm16Textures.Reset();
    326  }
    327 
    328  struct {
    329    FeatureState mWr;
    330    FeatureState mWrCompositor;
    331    FeatureState mWrAngle;
    332    FeatureState mWrDComp;
    333    FeatureState mWrPartial;
    334    FeatureState mWrShaderCache;
    335    FeatureState mWrOptimizedShaders;
    336    FeatureState mWrScissoredCacheClears;
    337    FeatureState mHwCompositing;
    338    FeatureState mD3D11HwAngle;
    339    FeatureState mD3D11Compositing;
    340    FeatureState mGPUProcess;
    341    FeatureState mGLNorm16Textures;
    342  } mFeatures;
    343 
    344  RefPtr<MockGfxInfo> mMockGfxInfo;
    345 };
    346 
    347 }  // namespace gfx
    348 }  // namespace mozilla
    349 
    350 TEST_F(GfxConfigManager, WebRenderDefault) {
    351  ConfigureWebRender();
    352 
    353  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    354  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    355  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    356  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    357  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    358  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    359  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    360  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    361  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    362  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    363  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    364  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    365 }
    366 
    367 TEST_F(GfxConfigManager, WebRenderDefaultRelease) {
    368  mIsNightly = mIsEarlyBetaOrEarlier = false;
    369  ConfigureWebRender();
    370 
    371  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    372  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    373  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    374  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    375  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    376  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    377  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    378  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    379  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    380  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    381  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    382  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    383 }
    384 
    385 TEST_F(GfxConfigManager, WebRenderNoPartialPresent) {
    386  mWrPartialPresent = false;
    387  ConfigureWebRender();
    388 
    389  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    390  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    391  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    392  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    393  EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled());
    394  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    395  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    396  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    397  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    398  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    399  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    400  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    401 }
    402 
    403 TEST_F(GfxConfigManager, WebRenderPartialBlocked) {
    404  mWrPartialPresent = true;
    405  mMockGfxInfo->mStatusWrPartialPresent = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    406  ConfigureWebRender();
    407 
    408  EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled());
    409 }
    410 
    411 TEST_F(GfxConfigManager, WebRenderForcePartialBlocked) {
    412  mWrForcePartialPresent = true;
    413  mMockGfxInfo->mStatusWrPartialPresent = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    414  ConfigureWebRender();
    415 
    416  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    417 }
    418 
    419 TEST_F(GfxConfigManager, WebRenderScaledResolutionWithHwStretching) {
    420  mScaledResolution = true;
    421  ConfigureWebRender();
    422 
    423  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    424  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    425  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    426  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    427  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    428  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    429  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    430  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    431  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    432  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    433  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    434  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    435 }
    436 
    437 TEST_F(GfxConfigManager, WebRenderScaledResolutionNoHwStretching) {
    438  ++mHwStretchingSupport.mNone;
    439  mScaledResolution = true;
    440  ConfigureWebRender();
    441 
    442  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    443  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    444  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    445  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    446  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    447  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    448  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    449  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    450  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    451  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    452  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    453  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    454 }
    455 
    456 TEST_F(GfxConfigManager, WebRenderEnabledWithDisableHwCompositingNoWr) {
    457  mDisableHwCompositingNoWr = true;
    458  ConfigureWebRender();
    459 
    460  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    461  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    462  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    463  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    464  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    465  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    466  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    467  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    468  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    469  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    470  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    471  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    472 }
    473 
    474 TEST_F(GfxConfigManager, WebRenderDisabledWithDisableHwCompositingNoWr) {
    475  mDisableHwCompositingNoWr = true;
    476  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    477  ConfigureWebRender();
    478 
    479  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    480  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    481  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    482  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    483  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    484  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    485  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    486  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    487  EXPECT_FALSE(mFeatures.mHwCompositing.IsEnabled());
    488  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    489  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    490  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    491 }
    492 
    493 TEST_F(GfxConfigManager, WebRenderSafeMode) {
    494  mSafeMode = true;
    495  ConfigureWebRender();
    496 
    497  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    498  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    499  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    500  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    501  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    502  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    503  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    504  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    505  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    506  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    507  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    508  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    509 }
    510 
    511 TEST_F(GfxConfigManager, WebRenderDCompDisabled) {
    512  mWrDCompWinEnabled = false;
    513  ConfigureWebRender();
    514 
    515  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    516  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    517  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    518  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    519  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    520  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    521  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    522  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    523  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    524  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    525  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    526  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    527 }
    528 
    529 TEST_F(GfxConfigManager, WebRenderDCompNotRequired) {
    530  mWrDCompWinEnabled = false;
    531  mWrCompositorDCompRequired = false;
    532  ConfigureWebRender();
    533 
    534  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    535  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    536  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    537  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    538  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    539  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    540  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    541  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    542  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    543  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    544  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    545  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    546 }
    547 
    548 TEST_F(GfxConfigManager, WebRenderDCompBlocked) {
    549  mWrPartialPresent = true;
    550  mMockGfxInfo->mStatusWrDComp = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    551  ConfigureWebRender();
    552 
    553  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    554  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    555  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    556  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    557  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    558  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    559  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    560  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    561  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    562  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    563  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    564  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    565 }
    566 
    567 TEST_F(GfxConfigManager, WebRenderForceAngleDisabled) {
    568  mWrForceAngle = false;
    569  ConfigureWebRender();
    570 
    571  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    572  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    573  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
    574  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    575  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    576  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    577  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    578  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    579  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    580  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    581  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    582  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    583 }
    584 
    585 TEST_F(GfxConfigManager, WebRenderD3D11HwAngleDisabled) {
    586  mFeatures.mD3D11HwAngle.UserDisable("", ""_ns);
    587  ConfigureWebRender();
    588 
    589  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    590  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    591  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
    592  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    593  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    594  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    595  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    596  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    597  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    598  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    599  EXPECT_FALSE(mFeatures.mD3D11HwAngle.IsEnabled());
    600  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    601 }
    602 
    603 TEST_F(GfxConfigManager, WebRenderD3D11HwAngleAndForceAngleDisabled) {
    604  mWrForceAngle = false;
    605  mFeatures.mD3D11HwAngle.UserDisable("", ""_ns);
    606  ConfigureWebRender();
    607 
    608  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    609  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    610  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
    611  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    612  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    613  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    614  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    615  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    616  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    617  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    618  EXPECT_FALSE(mFeatures.mD3D11HwAngle.IsEnabled());
    619  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    620 }
    621 
    622 TEST_F(GfxConfigManager, WebRenderGPUProcessDisabled) {
    623  mFeatures.mGPUProcess.UserDisable("", ""_ns);
    624  ConfigureWebRender();
    625 
    626  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    627  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    628  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
    629  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    630  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    631  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    632  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    633  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    634  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    635  EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled());
    636  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    637  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    638 }
    639 
    640 TEST_F(GfxConfigManager, WebRenderIntelBatteryNoHwStretchingNotNightly) {
    641  mIsNightly = mIsEarlyBetaOrEarlier = false;
    642  ++mHwStretchingSupport.mNone;
    643  mScaledResolution = true;
    644  mMockGfxInfo->mHasBattery.ref() = true;
    645  mMockGfxInfo->mVendorId = "0x8086";
    646  ConfigureWebRender();
    647 
    648  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    649  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    650  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    651  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    652  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    653  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    654  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    655  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    656  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    657  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    658  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    659  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    660 }
    661 
    662 TEST_F(GfxConfigManager, WebRenderSofwareAndNotQualified) {
    663  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    664  ConfigureWebRender();
    665 
    666  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    667  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    668  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    669  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    670  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    671  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    672  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    673  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    674  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    675  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    676  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    677  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    678 }
    679 
    680 TEST_F(GfxConfigManager, WebRenderForceEnabledEnvvar) {
    681  mWrEnvForceEnabled = true;
    682  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    683  ConfigureWebRender();
    684 
    685  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    686  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    687  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    688  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    689  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    690  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    691  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    692  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    693  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    694  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    695  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    696  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    697 }
    698 
    699 TEST_F(GfxConfigManager, WebRenderSoftwareAllowedForceEnabledPref) {
    700  mWrForceEnabled = true;
    701  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    702  ConfigureWebRender();
    703 
    704  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    705  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    706  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    707  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    708  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    709  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    710  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    711  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    712  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    713  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    714  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    715  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    716 }
    717 
    718 TEST_F(GfxConfigManager, WebRenderForceSoftwareForceEnabledEnvvar) {
    719  mWrEnvForceEnabled = true;
    720  mWrSoftwareForceEnabled = true;
    721  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    722  ConfigureWebRender();
    723 
    724  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    725  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    726  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    727  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    728  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    729  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    730  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    731  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    732  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    733  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    734  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    735  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    736 }
    737 
    738 TEST_F(GfxConfigManager, WebRenderSoftwareReleaseWindowsGPUProcessDisabled) {
    739  mIsNightly = mIsEarlyBetaOrEarlier = false;
    740  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    741  mFeatures.mGPUProcess.UserDisable("", ""_ns);
    742  ConfigureWebRender();
    743 
    744  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
    745  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
    746  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
    747  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
    748  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    749  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    750  EXPECT_FALSE(mFeatures.mWrOptimizedShaders.IsEnabled());
    751  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    752  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    753  EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled());
    754  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    755  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    756 }
    757 
    758 TEST_F(GfxConfigManager, WebRenderShaderCacheDisabled) {
    759  mWrShaderCache = Some(false);
    760  ConfigureWebRender();
    761 
    762  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    763  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    764  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    765  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    766  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    767  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    768  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    769  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    770  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    771  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    772  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    773  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    774 }
    775 
    776 TEST_F(GfxConfigManager, WebRenderShaderCacheBlocked) {
    777  mMockGfxInfo->mStatusWrShaderCache = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    778  ConfigureWebRender();
    779 
    780  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    781  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    782  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    783  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    784  EXPECT_FALSE(mFeatures.mWrShaderCache.IsEnabled());
    785  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    786  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    787  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    788  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    789  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    790  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    791  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    792 }
    793 
    794 TEST_F(GfxConfigManager, WebRenderScissoredCacheClearsDisabled) {
    795  mWrScissoredCacheClearsEnabled = false;
    796  ConfigureWebRender();
    797 
    798  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    799  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    800  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    801  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    802  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    803  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    804  EXPECT_FALSE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    805  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    806  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    807  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    808  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    809  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    810 }
    811 
    812 TEST_F(GfxConfigManager, WebRenderScissoredCacheClearsBlocked) {
    813  mMockGfxInfo->mStatusWrScissoredCacheClears =
    814      nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    815  ConfigureWebRender();
    816 
    817  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    818  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    819  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    820  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    821  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    822  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    823  EXPECT_FALSE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    824  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    825  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    826  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    827  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    828  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    829 }
    830 
    831 TEST_F(GfxConfigManager, WebRenderScissoredCacheClearsForceEnabled) {
    832  mWrScissoredCacheClearsForceEnabled = false;
    833  mMockGfxInfo->mStatusWrScissoredCacheClears =
    834      nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    835  ConfigureWebRender();
    836 
    837  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    838  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    839  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    840  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    841  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    842  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    843  EXPECT_FALSE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    844  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    845  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    846  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    847  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    848  EXPECT_TRUE(mFeatures.mGLNorm16Textures.IsEnabled());
    849 }
    850 
    851 TEST_F(GfxConfigManager, GLNorm16TexturesBlocked) {
    852  mMockGfxInfo->mStatusGLNorm16Textures = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
    853  ConfigureWebRender();
    854 
    855  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
    856  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
    857  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
    858  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
    859  EXPECT_TRUE(mFeatures.mWrShaderCache.IsEnabled());
    860  EXPECT_TRUE(mFeatures.mWrOptimizedShaders.IsEnabled());
    861  EXPECT_TRUE(mFeatures.mWrScissoredCacheClears.IsEnabled());
    862  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
    863  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
    864  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
    865  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
    866  EXPECT_FALSE(mFeatures.mGLNorm16Textures.IsEnabled());
    867 }