# Global Metrics

path: .metrics.mi.mi_original
old: 26.554801239505323
new: -25.247638640227436
path: .metrics.mi.mi_sei
old: -12.731422063166413
new: -74.65514418594913
path: .metrics.mi.mi_visual_studio
old: 15.529123531874458
new: 0.0
path: .metrics.cyclomatic.sum
old: 15.0
new: 152.0
path: .metrics.cyclomatic.average
old: 1.6666666666666667
new: 2.235294117647059
path: .metrics.cognitive.average
old: 1.8571428571428572
new: 2.15625
path: .metrics.cognitive.sum
old: 13.0
new: 138.0
path: .metrics.nargs.sum
old: 12.0
new: 54.0
path: .metrics.nargs.average
old: 1.7142857142857142
new: 0.84375
path: .metrics.loc.sloc
old: 332.0
new: 833.0
path: .metrics.loc.lloc
old: 89.0
new: 293.0
path: .metrics.loc.cloc
old: 32.0
new: 72.0
path: .metrics.loc.ploc
old: 257.0
new: 636.0
path: .metrics.loc.blank
old: 43.0
new: 125.0
path: .metrics.halstead.N1
old: 549.0
new: 1667.0
path: .metrics.halstead.time
old: 18243.03877653608
new: 64774.31782673867
path: .metrics.halstead.length
old: 1100.0
new: 2745.0
path: .metrics.halstead.bugs
old: 1.5865674358293966
new: 3.6925720714903343
path: .metrics.halstead.volume
old: 8343.458750793272
new: 23524.253644868448
path: .metrics.halstead.n1
old: 24.0
new: 32.0
path: .metrics.halstead.n2
old: 168.0
new: 348.0
path: .metrics.halstead.N2
old: 551.0
new: 1078.0
path: .metrics.halstead.effort
old: 328374.69797764946
new: 1165937.720881296
path: .metrics.halstead.purity_ratio
old: 1.2290440245855814
new: 1.1286500315320065
path: .metrics.halstead.difficulty
old: 39.357142857142854
new: 49.5632183908046
path: .metrics.halstead.estimated_program_length
old: 1351.9484270441394
new: 3098.1443365553578
path: .metrics.halstead.vocabulary
old: 192.0
new: 380.0
path: .metrics.halstead.level
old: 0.025408348457350273
new: 0.02017625231910946
path: .metrics.nexits.sum
old: 2.0
new: 81.0
path: .metrics.nexits.average
old: 0.2857142857142857
new: 1.265625
path: .metrics.nom.functions
old: 7.0
new: 64.0
path: .metrics.nom.total
old: 7.0
new: 64.0

# Spaces Data

## Minimal test - lines (21, 833)

path: .spaces[0].metrics.cyclomatic.average
old: 1.0
new: 2.253731343283582
path: .spaces[0].metrics.cyclomatic.sum
old: 2.0
new: 151.0
path: .spaces[0].metrics.cognitive.sum
old: 0.0
new: 138.0
path: .spaces[0].metrics.cognitive.average
old: 0.0
new: 2.15625
path: .spaces[0].metrics.nargs.sum
old: 0.0
new: 54.0
path: .spaces[0].metrics.nargs.average
old: 0.0
new: 0.84375
path: .spaces[0].metrics.loc.sloc
old: 18.0
new: 813.0
path: .spaces[0].metrics.loc.cloc
old: 2.0
new: 67.0
path: .spaces[0].metrics.loc.lloc
old: 3.0
new: 293.0
path: .spaces[0].metrics.loc.blank
old: 2.0
new: 122.0
path: .spaces[0].metrics.loc.ploc
old: 14.0
new: 624.0
path: .spaces[0].metrics.halstead.vocabulary
old: 33.0
new: 368.0
path: .spaces[0].metrics.halstead.estimated_program_length
old: 135.25821588700785
new: 2979.8186540536635
path: .spaces[0].metrics.halstead.n1
old: 12.0
new: 32.0
path: .spaces[0].metrics.halstead.level
old: 0.12068965517241378
new: 0.019699812382739212
path: .spaces[0].metrics.halstead.volume
old: 312.7524354002241
new: 23294.894825903815
path: .spaces[0].metrics.halstead.bugs
old: 0.06288771973478276
new: 3.727444518821845
path: .spaces[0].metrics.halstead.n2
old: 21.0
new: 336.0
path: .spaces[0].metrics.halstead.N2
old: 29.0
new: 1066.0
path: .spaces[0].metrics.halstead.effort
old: 2591.3773218875713
new: 1182493.2325911175
path: .spaces[0].metrics.halstead.length
old: 62.0
new: 2733.0
path: .spaces[0].metrics.halstead.N1
old: 33.0
new: 1667.0
path: .spaces[0].metrics.halstead.time
old: 143.96540677153175
new: 65694.06847728431
path: .spaces[0].metrics.halstead.purity_ratio
old: 2.181584127209804
new: 1.0903105210587865
path: .spaces[0].metrics.halstead.difficulty
old: 8.285714285714286
new: 50.76190476190476
path: .spaces[0].metrics.nom.functions
old: 1.0
new: 64.0
path: .spaces[0].metrics.nom.total
old: 1.0
new: 64.0
path: .spaces[0].metrics.mi.mi_visual_studio
old: 54.87709675612262
new: 0.0
path: .spaces[0].metrics.mi.mi_sei
old: 84.57259521298842
new: -74.26661406962015
path: .spaces[0].metrics.mi.mi_original
old: 93.83983545296968
new: -24.572989423357654
path: .spaces[0].metrics.nexits.average
old: 0.0
new: 1.265625
path: .spaces[0].metrics.nexits.sum
old: 0.0
new: 81.0

### Code

    namespace mozilla {
    namespace widget {

    class GfxInfo::GLStrings {
      nsCString mVendor;
      nsCString mRenderer;
      nsCString mVersion;
      nsTArray mExtensions;
      bool mReady;

     public:
      GLStrings() : mReady(false) {}

      const nsCString& Vendor() {
        EnsureInitialized();
        return mVendor;
      }

      // This spoofed value wins, even if the environment variable
      // MOZ_GFX_SPOOF_GL_VENDOR was set.
      void SpoofVendor(const nsCString& s) { mVendor = s; }

      const nsCString& Renderer() {
        EnsureInitialized();
        return mRenderer;
      }

      // This spoofed value wins, even if the environment variable
      // MOZ_GFX_SPOOF_GL_RENDERER was set.
      void SpoofRenderer(const nsCString& s) { mRenderer = s; }

      const nsCString& Version() {
        EnsureInitialized();
        return mVersion;
      }

      // This spoofed value wins, even if the environment variable
      // MOZ_GFX_SPOOF_GL_VERSION was set.
      void SpoofVersion(const nsCString& s) { mVersion = s; }

      const nsTArray& Extensions() {
        EnsureInitialized();
        return mExtensions;
      }

      void EnsureInitialized() {
        if (mReady) {
          return;
        }

        RefPtr gl;
        nsCString discardFailureId;
        gl = gl::GLContextProvider::CreateHeadless(
            {gl::CreateContextFlags::REQUIRE_COMPAT_PROFILE}, &discardFailureId);

        if (!gl) {
          // Setting mReady to true here means that we won't retry. Everything will
          // remain blocklisted forever. Ideally, we would like to update that once
          // any GLContext is successfully created, like the compositor's GLContext.
          mReady = true;
          return;
        }

        gl->MakeCurrent();

        if (mVendor.IsEmpty()) {
          const char* spoofedVendor = PR_GetEnv("MOZ_GFX_SPOOF_GL_VENDOR");
          if (spoofedVendor) {
            mVendor.Assign(spoofedVendor);
          } else {
            mVendor.Assign((const char*)gl->fGetString(LOCAL_GL_VENDOR));
          }
        }

        if (mRenderer.IsEmpty()) {
          const char* spoofedRenderer = PR_GetEnv("MOZ_GFX_SPOOF_GL_RENDERER");
          if (spoofedRenderer) {
            mRenderer.Assign(spoofedRenderer);
          } else {
            mRenderer.Assign((const char*)gl->fGetString(LOCAL_GL_RENDERER));
          }
        }

        if (mVersion.IsEmpty()) {
          const char* spoofedVersion = PR_GetEnv("MOZ_GFX_SPOOF_GL_VERSION");
          if (spoofedVersion) {
            mVersion.Assign(spoofedVersion);
          } else {
            mVersion.Assign((const char*)gl->fGetString(LOCAL_GL_VERSION));
          }
        }

        if (mExtensions.IsEmpty()) {
          nsCString rawExtensions;
          rawExtensions.Assign((const char*)gl->fGetString(LOCAL_GL_EXTENSIONS));
          rawExtensions.Trim(" ");

          for (auto extension : rawExtensions.Split(' ')) {
            mExtensions.AppendElement(extension);
          }
        }

        mReady = true;
      }
    };

    #ifdef DEBUG
    NS_IMPL_ISUPPORTS_INHERITED(GfxInfo, GfxInfoBase, nsIGfxInfoDebug)
    #endif

    GfxInfo::GfxInfo()
        : mInitialized(false),
          mGLStrings(new GLStrings),
          mOSVersionInteger(0),
          mSDKVersion(0) {}

    GfxInfo::~GfxInfo() {}

    /* GetD2DEnabled and GetDwriteEnabled shouldn't be called until after
     * gfxPlatform initialization has occurred because they depend on it for
     * information. (See bug 591561) */
    nsresult GfxInfo::GetD2DEnabled(bool* aEnabled) { return NS_ERROR_FAILURE; }

    nsresult GfxInfo::GetDWriteEnabled(bool* aEnabled) { return NS_ERROR_FAILURE; }

    nsresult GfxInfo::GetHasBattery(bool* aHasBattery) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    NS_IMETHODIMP
    GfxInfo::GetDWriteVersion(nsAString& aDwriteVersion) {
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetEmbeddedInFirefoxReality(bool* aEmbeddedInFirefoxReality) {
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetCleartypeParameters(nsAString& aCleartypeParams) {
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetWindowProtocol(nsAString& aWindowProtocol) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    NS_IMETHODIMP
    GfxInfo::GetDesktopEnvironment(nsAString& aDesktopEnvironment) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    NS_IMETHODIMP
    GfxInfo::GetTestType(nsAString& aTestType) { return NS_ERROR_NOT_IMPLEMENTED; }

    void GfxInfo::EnsureInitialized() {
      if (mInitialized) return;

      if (!mozilla::AndroidBridge::Bridge()) {
        gfxWarning() << "AndroidBridge missing during initialization";
        return;
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticStringField("android/os/Build",
                                                                 "MODEL", mModel)) {
        mAdapterDescription.AppendPrintf("Model: %s",
                                         NS_LossyConvertUTF16toASCII(mModel).get());
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticStringField(
              "android/os/Build", "PRODUCT", mProduct)) {
        mAdapterDescription.AppendPrintf(
            ", Product: %s", NS_LossyConvertUTF16toASCII(mProduct).get());
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticStringField(
              "android/os/Build", "MANUFACTURER", mManufacturer)) {
        mAdapterDescription.AppendPrintf(
            ", Manufacturer: %s", NS_LossyConvertUTF16toASCII(mManufacturer).get());
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticIntField(
              "android/os/Build$VERSION", "SDK_INT", &mSDKVersion)) {
        // the HARDWARE field isn't available on Android SDK < 8, but we require 9+
        // anyway.
        MOZ_ASSERT(mSDKVersion >= 8);
        if (mozilla::AndroidBridge::Bridge()->GetStaticStringField(
                "android/os/Build", "HARDWARE", mHardware)) {
          mAdapterDescription.AppendPrintf(
              ", Hardware: %s", NS_LossyConvertUTF16toASCII(mHardware).get());
        }
      } else {
        mSDKVersion = 0;
      }

      nsString release;
      mozilla::AndroidBridge::Bridge()->GetStaticStringField(
          "android/os/Build$VERSION", "RELEASE", release);
      mOSVersion = NS_LossyConvertUTF16toASCII(release);

      mOSVersionInteger = 0;
      char a[5], b[5], c[5], d[5];
      SplitDriverVersion(mOSVersion.get(), a, b, c, d);
      uint8_t na = atoi(a);
      uint8_t nb = atoi(b);
      uint8_t nc = atoi(c);
      uint8_t nd = atoi(d);

      mOSVersionInteger = (uint32_t(na) << 24) | (uint32_t(nb) << 16) |
                          (uint32_t(nc) << 8) | uint32_t(nd);

      mAdapterDescription.AppendPrintf(
          ", OpenGL: %s -- %s -- %s", mGLStrings->Vendor().get(),
          mGLStrings->Renderer().get(), mGLStrings->Version().get());

      AddCrashReportAnnotations();

      mScreenInfo.mScreenDimensions =
          mozilla::AndroidBridge::Bridge()->getScreenSize();

      mInitialized = true;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDescription(nsAString& aAdapterDescription) {
      EnsureInitialized();
      aAdapterDescription = NS_ConvertASCIItoUTF16(mAdapterDescription);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDescription2(nsAString& aAdapterDescription) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterRAM(uint32_t* aAdapterRAM) {
      EnsureInitialized();
      *aAdapterRAM = 0;
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterRAM2(uint32_t* aAdapterRAM) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriver(nsAString& aAdapterDriver) {
      EnsureInitialized();
      aAdapterDriver.Truncate();
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
      EnsureInitialized();
      aAdapterDriverVendor.Truncate();
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
      EnsureInitialized();
      aAdapterDriverVersion = NS_ConvertASCIItoUTF16(mGLStrings->Version());
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVersion2(nsAString& aAdapterDriverVersion) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverDate(nsAString& aAdapterDriverDate) {
      EnsureInitialized();
      aAdapterDriverDate.Truncate();
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverDate2(nsAString& aAdapterDriverDate) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterVendorID(nsAString& aAdapterVendorID) {
      EnsureInitialized();
      aAdapterVendorID = NS_ConvertASCIItoUTF16(mGLStrings->Vendor());
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterVendorID2(nsAString& aAdapterVendorID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDeviceID(nsAString& aAdapterDeviceID) {
      EnsureInitialized();
      aAdapterDeviceID = NS_ConvertASCIItoUTF16(mGLStrings->Renderer());
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDeviceID2(nsAString& aAdapterDeviceID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterSubsysID(nsAString& aAdapterSubsysID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterSubsysID2(nsAString& aAdapterSubsysID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetDisplayInfo(nsTArray& aDisplayInfo) {
      EnsureInitialized();
      nsString displayInfo;
      displayInfo.AppendPrintf("%dx%d",
                               (int32_t)mScreenInfo.mScreenDimensions.width,
                               (int32_t)mScreenInfo.mScreenDimensions.height);
      aDisplayInfo.AppendElement(displayInfo);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetDisplayWidth(nsTArray& aDisplayWidth) {
      aDisplayWidth.AppendElement((uint32_t)mScreenInfo.mScreenDimensions.width);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetDisplayHeight(nsTArray& aDisplayHeight) {
      aDisplayHeight.AppendElement((uint32_t)mScreenInfo.mScreenDimensions.height);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetDrmRenderDevice(nsACString& aDrmRenderDevice) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    void GfxInfo::AddCrashReportAnnotations() {
      CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterVendorID,
                                         mGLStrings->Vendor());
      CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterDeviceID,
                                         mGLStrings->Renderer());
      CrashReporter::AnnotateCrashReport(
          CrashReporter::Annotation::AdapterDriverVersion, mGLStrings->Version());
    }

    const nsTArray& GfxInfo::GetGfxDriverInfo() {
      if (sDriverInfo->IsEmpty()) {
        APPEND_TO_DRIVER_BLOCKLIST2(
            OperatingSystem::Android, DeviceFamily::All,
            nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_STATUS_OK,
            DRIVER_COMPARISON_IGNORED, GfxDriverInfo::allDriverVersions,
            "FEATURE_OK_FORCE_OPENGL");
      }

      return *sDriverInfo;
    }

    nsresult GfxInfo::GetFeatureStatusImpl(
        int32_t aFeature, int32_t* aStatus, nsAString& aSuggestedDriverVersion,
        const nsTArray& aDriverInfo, nsACString& aFailureId,
        OperatingSystem* aOS /* = nullptr */) {
      NS_ENSURE_ARG_POINTER(aStatus);
      aSuggestedDriverVersion.SetIsVoid(true);
      *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
      OperatingSystem os = mOS;
      if (aOS) *aOS = os;

      if (sShutdownOccurred) {
        return NS_OK;
      }

      // OpenGL layers are never blocklisted on Android.
      // This early return is so we avoid potentially slow
      // GLStrings initialization on startup when we initialize GL layers.
      if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS) {
        *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
        return NS_OK;
      }

      EnsureInitialized();

      if (mGLStrings->Vendor().IsEmpty() || mGLStrings->Renderer().IsEmpty()) {
        *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
        return NS_OK;
      }

      // Don't evaluate special cases when evaluating the downloaded blocklist.
      if (aDriverInfo.IsEmpty()) {
        if (aFeature == nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION) {
          if (mSDKVersion < 11) {
            // It's slower than software due to not having a compositing fast path
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
            aFailureId = "FEATURE_FAILURE_CANVAS_2D_SDK";
          } else if (mGLStrings->Renderer().Find("Vivante GC1000") != -1) {
            // Blocklist Vivante GC1000. See bug 1248183.
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILED_CANVAS_2D_HW";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBGL_OPENGL) {
          if (mGLStrings->Renderer().Find("Adreno 200") != -1 ||
              mGLStrings->Renderer().Find("Adreno 205") != -1) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_ADRENO_20x";
            return NS_OK;
          }

          if (mSDKVersion <= 17) {
            if (mGLStrings->Renderer().Find("Adreno (TM) 3") != -1) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_ADRENO_3xx";
            }
            return NS_OK;
          }

          if (mHardware.EqualsLiteral("ville")) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_VILLE";
            return NS_OK;
          }
        }

        if (aFeature == FEATURE_STAGEFRIGHT) {
          NS_LossyConvertUTF16toASCII cManufacturer(mManufacturer);
          NS_LossyConvertUTF16toASCII cModel(mModel);
          NS_LossyConvertUTF16toASCII cHardware(mHardware);

          if (cHardware.EqualsLiteral("antares") ||
              cHardware.EqualsLiteral("harmony") ||
              cHardware.EqualsLiteral("picasso") ||
              cHardware.EqualsLiteral("picasso_e") ||
              cHardware.EqualsLiteral("ventana") ||
              cHardware.EqualsLiteral("rk30board")) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_STAGE_HW";
            return NS_OK;
          }

          if (CompareVersions(mOSVersion.get(), "4.1.0") < 0) {
            // Whitelist:
            //   All Samsung ICS devices, except for:
            //     Samsung SGH-I717 (Bug 845729)
            //     Samsung SGH-I727 (Bug 845729)
            //     Samsung SGH-I757 (Bug 845729)
            //   All Galaxy nexus ICS devices
            //   Sony Xperia Ion (LT28) ICS devices
            bool isWhitelisted =
                cModel.Equals("LT28h", nsCaseInsensitiveCStringComparator) ||
                cManufacturer.Equals("samsung",
                                     nsCaseInsensitiveCStringComparator) ||
                cModel.Equals(
                    "galaxy nexus",
                    nsCaseInsensitiveCStringComparator);  // some Galaxy Nexus
                                                          // have
                                                          // manufacturer=amazon

            if (cModel.Find("SGH-I717", true) != -1 ||
                cModel.Find("SGH-I727", true) != -1 ||
                cModel.Find("SGH-I757", true) != -1) {
              isWhitelisted = false;
            }

            if (!isWhitelisted) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_4_1_HW";
              return NS_OK;
            }
          } else if (CompareVersions(mOSVersion.get(), "4.2.0") < 0) {
            // Whitelist:
            //   All JB phones except for those in blocklist below
            // Blocklist:
            //   Samsung devices from bug 812881 and 853522.
            //   Motorola XT890 from bug 882342.
            bool isBlocklisted = cModel.Find("GT-P3100", true) != -1 ||
                                 cModel.Find("GT-P3110", true) != -1 ||
                                 cModel.Find("GT-P3113", true) != -1 ||
                                 cModel.Find("GT-P5100", true) != -1 ||
                                 cModel.Find("GT-P5110", true) != -1 ||
                                 cModel.Find("GT-P5113", true) != -1 ||
                                 cModel.Find("XT890", true) != -1;

            if (isBlocklisted) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_4_2_HW";
              return NS_OK;
            }
          } else if (CompareVersions(mOSVersion.get(), "4.3.0") < 0) {
            // Blocklist all Sony devices
            if (cManufacturer.Find("Sony", true) != -1) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_4_3_SONY";
              return NS_OK;
            }
          }
        }

        if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_ENCODE) {
          if (mozilla::AndroidBridge::Bridge()) {
            *aStatus = WebRtcHwVp8EncodeSupported();
            aFailureId = "FEATURE_FAILURE_WEBRTC_ENCODE";
            return NS_OK;
          }
        }
        if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_DECODE) {
          if (mozilla::AndroidBridge::Bridge()) {
            *aStatus = WebRtcHwVp8DecodeSupported();
            aFailureId = "FEATURE_FAILURE_WEBRTC_DECODE";
            return NS_OK;
          }
        }
        if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_H264) {
          if (mozilla::AndroidBridge::Bridge()) {
            *aStatus = WebRtcHwH264Supported();
            aFailureId = "FEATURE_FAILURE_WEBRTC_H264";
            return NS_OK;
          }
        }
        if (aFeature == FEATURE_VP8_HW_DECODE ||
            aFeature == FEATURE_VP9_HW_DECODE) {
          NS_LossyConvertUTF16toASCII model(mModel);
          bool isBlocked =
              // GIFV crash, see bug 1232911.
              model.Equals("GT-N8013", nsCaseInsensitiveCStringComparator);

          if (isBlocked) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_VPx";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBRENDER) {
          bool isUnblocked = false;
          const nsCString& gpu = mGLStrings->Renderer();
          NS_LossyConvertUTF16toASCII model(mModel);

    #ifdef NIGHTLY_BUILD
          // On Nightly enable Webrender on all Adreno 4xx GPUs
          isUnblocked |= gpu.Find("Adreno (TM) 4", /*ignoreCase*/ true) >= 0;
    #endif
          // Enable Webrender on all Adreno 5xx and 6xx GPUs
          isUnblocked |= gpu.Find("Adreno (TM) 5", /*ignoreCase*/ true) >= 0 ||
                         gpu.Find("Adreno (TM) 6", /*ignoreCase*/ true) >= 0;

          // Enable Webrender on all Mali-Txxx GPUs
          isUnblocked |= gpu.Find("Mali-T", /*ignoreCase*/ true) >= 0;

          // Enable Webrender on all Mali-Gxx GPUs...
          isUnblocked |= gpu.Find("Mali-G", /*ignoreCase*/ true) >= 0 &&
                         // Excluding G31 due to bug 1689947.
                         gpu.Find("Mali-G31", /*ignoreCase*/ true) == kNotFound;

          // Webrender requires the extension GL_OES_EGL_image_external_essl3
          // to render video. Bug 1507074 tracks removing this requirement.
          bool supportsImageExternalEssl3 = mGLStrings->Extensions().Contains(
              "GL_OES_EGL_image_external_essl3"_ns);

          if (!isUnblocked) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_WEBRENDER_BLOCKED_DEVICE";
          } else if (!supportsImageExternalEssl3) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_WEBRENDER_NO_IMAGE_EXTERNAL";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_ALLOW_QUALIFIED;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBRENDER_SCISSORED_CACHE_CLEARS) {
          // Emulator with SwiftShader is buggy when attempting to clear picture
          // cache textures with a scissor rect set.
          const bool isEmulatorSwiftShader =
              mGLStrings->Renderer().Find(
                  "Android Emulator OpenGL ES Translator (Google SwiftShader)") >=
              0;
          if (isEmulatorSwiftShader) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_BUG_1603515";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBRENDER_OPTIMIZED_SHADERS) {
          // Optimized shaders result in completely broken rendering in at least one
          // Mali-T6xx device. Disable on all T6xx as a precaution until we know
          // more specifically which devices are affected. See bug 1689064 for
          // details.
          const bool isMaliT6xx =
              mGLStrings->Renderer().Find("Mali-T6", /*ignoreCase*/ true) >= 0;
          if (isMaliT6xx) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_BUG_1689064";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }
      }

      return GfxInfoBase::GetFeatureStatusImpl(
          aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, aFailureId, &os);
    }

    static nsCString FeatureCacheOsVerPrefName(int32_t aFeature) {
      nsCString osPrefName;
      osPrefName.AppendASCII("gfxinfo.cache.");
      osPrefName.AppendInt(aFeature);
      osPrefName.AppendASCII(".osver");
      return osPrefName;
    }

    static nsCString FeatureCacheValuePrefName(int32_t aFeature) {
      nsCString osPrefName;
      osPrefName.AppendASCII("gfxinfo.cache.");
      osPrefName.AppendInt(aFeature);
      osPrefName.AppendASCII(".value");
      return osPrefName;
    }

    static bool GetCachedFeatureVal(int32_t aFeature, uint32_t aExpectedOsVer,
                                    int32_t& aOutStatus) {
      uint32_t osVer = 0;
      nsresult rv =
          Preferences::GetUint(FeatureCacheOsVerPrefName(aFeature).get(), &osVer);
      if (NS_FAILED(rv) || osVer != aExpectedOsVer) {
        return false;
      }
      int32_t status = 0;
      rv = Preferences::GetInt(FeatureCacheValuePrefName(aFeature).get(), &status);
      if (NS_FAILED(rv)) {
        return false;
      }
      aOutStatus = status;
      return true;
    }

    static void SetCachedFeatureVal(int32_t aFeature, uint32_t aOsVer,
                                    int32_t aStatus) {
      // Ignore failures; not much we can do anyway.
      Preferences::SetUint(FeatureCacheOsVerPrefName(aFeature).get(), aOsVer);
      Preferences::SetInt(FeatureCacheValuePrefName(aFeature).get(), aStatus);
    }

    int32_t GfxInfo::WebRtcHwVp8EncodeSupported() {
      MOZ_ASSERT(mozilla::AndroidBridge::Bridge());

      // The Android side of this calculation is very slow, so we cache the result
      // in preferences, invalidating if the OS version changes.

      int32_t status = 0;
      if (GetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_ENCODE,
                              mOSVersionInteger, status)) {
        return status;
      }

      status = mozilla::AndroidBridge::Bridge()->HasHWVP8Encoder()
                   ? nsIGfxInfo::FEATURE_STATUS_OK
                   : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      SetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_ENCODE, mOSVersionInteger,
                          status);

      return status;
    }

    int32_t GfxInfo::WebRtcHwVp8DecodeSupported() {
      MOZ_ASSERT(mozilla::AndroidBridge::Bridge());

      // The Android side of this caclulation is very slow, so we cache the result
      // in preferences, invalidating if the OS version changes.

      int32_t status = 0;
      if (GetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_DECODE,
                              mOSVersionInteger, status)) {
        return status;
      }

      status = mozilla::AndroidBridge::Bridge()->HasHWVP8Decoder()
                   ? nsIGfxInfo::FEATURE_STATUS_OK
                   : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      SetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_DECODE, mOSVersionInteger,
                          status);

      return status;
    }

    int32_t GfxInfo::WebRtcHwH264Supported() {
      MOZ_ASSERT(mozilla::AndroidBridge::Bridge());

      // The Android side of this calculation is very slow, so we cache the result
      // in preferences, invalidating if the OS version changes.

      int32_t status = 0;
      if (GetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_H264,
                              mOSVersionInteger, status)) {
        return status;
      }

      status = mozilla::AndroidBridge::Bridge()->HasHWH264()
                   ? nsIGfxInfo::FEATURE_STATUS_OK
                   : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      SetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_H264, mOSVersionInteger,
                          status);

      return status;
    }

    #ifdef DEBUG

    // Implement nsIGfxInfoDebug

    NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString& aVendorID) {
      mGLStrings->SpoofVendor(NS_LossyConvertUTF16toASCII(aVendorID));
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString& aDeviceID) {
      mGLStrings->SpoofRenderer(NS_LossyConvertUTF16toASCII(aDeviceID));
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString& aDriverVersion) {
      mGLStrings->SpoofVersion(NS_LossyConvertUTF16toASCII(aDriverVersion));
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::SpoofOSVersion(uint32_t aVersion) {
      EnsureInitialized();
      mOSVersion = aVersion;
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::FireTestProcess() { return NS_OK; }

    #endif

    nsString GfxInfo::Model() {
      EnsureInitialized();
      return mModel;
    }

    nsString GfxInfo::Hardware() {
      EnsureInitialized();
      return mHardware;
    }

    nsString GfxInfo::Product() {
      EnsureInitialized();
      return mProduct;
    }

    nsString GfxInfo::Manufacturer() {
      EnsureInitialized();
      return mManufacturer;
    }

    uint32_t GfxInfo::OperatingSystemVersion() {
      EnsureInitialized();
      return mOSVersionInteger;
    }

    }  // namespace widget
    }  // namespace mozilla

## Minimal test - lines (22, 832)

path: .spaces[0].spaces[0].metrics.nom.functions
old: 1.0
new: 64.0
path: .spaces[0].spaces[0].metrics.nom.total
old: 1.0
new: 64.0
path: .spaces[0].spaces[0].metrics.nexits.sum
old: 0.0
new: 81.0
path: .spaces[0].spaces[0].metrics.nexits.average
old: 0.0
new: 1.265625
path: .spaces[0].spaces[0].metrics.cyclomatic.sum
old: 1.0
new: 150.0
path: .spaces[0].spaces[0].metrics.cyclomatic.average
old: 1.0
new: 2.272727272727273
path: .spaces[0].spaces[0].metrics.loc.lloc
old: 3.0
new: 293.0
path: .spaces[0].spaces[0].metrics.loc.blank
old: 2.0
new: 123.0
path: .spaces[0].spaces[0].metrics.loc.sloc
old: 15.0
new: 811.0
path: .spaces[0].spaces[0].metrics.loc.ploc
old: 11.0
new: 622.0
path: .spaces[0].spaces[0].metrics.loc.cloc
old: 2.0
new: 66.0
path: .spaces[0].spaces[0].metrics.halstead.estimated_program_length
old: 113.92990370430176
new: 2969.9857905906206
path: .spaces[0].spaces[0].metrics.halstead.purity_ratio
old: 2.071452794623668
new: 1.0875085282279826
path: .spaces[0].spaces[0].metrics.halstead.volume
old: 267.18895473201644
new: 23267.126606514816
path: .spaces[0].spaces[0].metrics.halstead.effort
old: 1898.4478362538011
new: 1183498.0220149625
path: .spaces[0].spaces[0].metrics.halstead.time
old: 105.46932423632228
new: 65749.89011194237
path: .spaces[0].spaces[0].metrics.halstead.N1
old: 28.0
new: 1666.0
path: .spaces[0].spaces[0].metrics.halstead.N2
old: 27.0
new: 1065.0
path: .spaces[0].spaces[0].metrics.halstead.difficulty
old: 7.105263157894737
new: 50.865671641791046
path: .spaces[0].spaces[0].metrics.halstead.level
old: 0.14074074074074072
new: 0.01965962441314554
path: .spaces[0].spaces[0].metrics.halstead.n2
old: 19.0
new: 335.0
path: .spaces[0].spaces[0].metrics.halstead.bugs
old: 0.05110670217663938
new: 3.729555745348911
path: .spaces[0].spaces[0].metrics.halstead.vocabulary
old: 29.0
new: 367.0
path: .spaces[0].spaces[0].metrics.halstead.length
old: 55.0
new: 2731.0
path: .spaces[0].spaces[0].metrics.halstead.n1
old: 10.0
new: 32.0
path: .spaces[0].spaces[0].metrics.mi.mi_sei
old: 92.35717585613271
new: -74.09599843722144
path: .spaces[0].spaces[0].metrics.mi.mi_original
old: 97.84221500276216
new: -24.296885670661155
path: .spaces[0].spaces[0].metrics.mi.mi_visual_studio
old: 57.21766959225858
new: 0.0
path: .spaces[0].spaces[0].metrics.nargs.sum
old: 0.0
new: 54.0
path: .spaces[0].spaces[0].metrics.nargs.average
old: 0.0
new: 0.84375
path: .spaces[0].spaces[0].metrics.cognitive.sum
old: 0.0
new: 138.0
path: .spaces[0].spaces[0].metrics.cognitive.average
old: 0.0
new: 2.15625

### Code

    namespace widget {

    class GfxInfo::GLStrings {
      nsCString mVendor;
      nsCString mRenderer;
      nsCString mVersion;
      nsTArray mExtensions;
      bool mReady;

     public:
      GLStrings() : mReady(false) {}

      const nsCString& Vendor() {
        EnsureInitialized();
        return mVendor;
      }

      // This spoofed value wins, even if the environment variable
      // MOZ_GFX_SPOOF_GL_VENDOR was set.
      void SpoofVendor(const nsCString& s) { mVendor = s; }

      const nsCString& Renderer() {
        EnsureInitialized();
        return mRenderer;
      }

      // This spoofed value wins, even if the environment variable
      // MOZ_GFX_SPOOF_GL_RENDERER was set.
      void SpoofRenderer(const nsCString& s) { mRenderer = s; }

      const nsCString& Version() {
        EnsureInitialized();
        return mVersion;
      }

      // This spoofed value wins, even if the environment variable
      // MOZ_GFX_SPOOF_GL_VERSION was set.
      void SpoofVersion(const nsCString& s) { mVersion = s; }

      const nsTArray& Extensions() {
        EnsureInitialized();
        return mExtensions;
      }

      void EnsureInitialized() {
        if (mReady) {
          return;
        }

        RefPtr gl;
        nsCString discardFailureId;
        gl = gl::GLContextProvider::CreateHeadless(
            {gl::CreateContextFlags::REQUIRE_COMPAT_PROFILE}, &discardFailureId);

        if (!gl) {
          // Setting mReady to true here means that we won't retry. Everything will
          // remain blocklisted forever. Ideally, we would like to update that once
          // any GLContext is successfully created, like the compositor's GLContext.
          mReady = true;
          return;
        }

        gl->MakeCurrent();

        if (mVendor.IsEmpty()) {
          const char* spoofedVendor = PR_GetEnv("MOZ_GFX_SPOOF_GL_VENDOR");
          if (spoofedVendor) {
            mVendor.Assign(spoofedVendor);
          } else {
            mVendor.Assign((const char*)gl->fGetString(LOCAL_GL_VENDOR));
          }
        }

        if (mRenderer.IsEmpty()) {
          const char* spoofedRenderer = PR_GetEnv("MOZ_GFX_SPOOF_GL_RENDERER");
          if (spoofedRenderer) {
            mRenderer.Assign(spoofedRenderer);
          } else {
            mRenderer.Assign((const char*)gl->fGetString(LOCAL_GL_RENDERER));
          }
        }

        if (mVersion.IsEmpty()) {
          const char* spoofedVersion = PR_GetEnv("MOZ_GFX_SPOOF_GL_VERSION");
          if (spoofedVersion) {
            mVersion.Assign(spoofedVersion);
          } else {
            mVersion.Assign((const char*)gl->fGetString(LOCAL_GL_VERSION));
          }
        }

        if (mExtensions.IsEmpty()) {
          nsCString rawExtensions;
          rawExtensions.Assign((const char*)gl->fGetString(LOCAL_GL_EXTENSIONS));
          rawExtensions.Trim(" ");

          for (auto extension : rawExtensions.Split(' ')) {
            mExtensions.AppendElement(extension);
          }
        }

        mReady = true;
      }
    };

    #ifdef DEBUG
    NS_IMPL_ISUPPORTS_INHERITED(GfxInfo, GfxInfoBase, nsIGfxInfoDebug)
    #endif

    GfxInfo::GfxInfo()
        : mInitialized(false),
          mGLStrings(new GLStrings),
          mOSVersionInteger(0),
          mSDKVersion(0) {}

    GfxInfo::~GfxInfo() {}

    /* GetD2DEnabled and GetDwriteEnabled shouldn't be called until after
     * gfxPlatform initialization has occurred because they depend on it for
     * information. (See bug 591561) */
    nsresult GfxInfo::GetD2DEnabled(bool* aEnabled) { return NS_ERROR_FAILURE; }

    nsresult GfxInfo::GetDWriteEnabled(bool* aEnabled) { return NS_ERROR_FAILURE; }

    nsresult GfxInfo::GetHasBattery(bool* aHasBattery) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    NS_IMETHODIMP
    GfxInfo::GetDWriteVersion(nsAString& aDwriteVersion) {
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetEmbeddedInFirefoxReality(bool* aEmbeddedInFirefoxReality) {
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetCleartypeParameters(nsAString& aCleartypeParams) {
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetWindowProtocol(nsAString& aWindowProtocol) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    NS_IMETHODIMP
    GfxInfo::GetDesktopEnvironment(nsAString& aDesktopEnvironment) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    NS_IMETHODIMP
    GfxInfo::GetTestType(nsAString& aTestType) { return NS_ERROR_NOT_IMPLEMENTED; }

    void GfxInfo::EnsureInitialized() {
      if (mInitialized) return;

      if (!mozilla::AndroidBridge::Bridge()) {
        gfxWarning() << "AndroidBridge missing during initialization";
        return;
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticStringField("android/os/Build",
                                                                 "MODEL", mModel)) {
        mAdapterDescription.AppendPrintf("Model: %s",
                                         NS_LossyConvertUTF16toASCII(mModel).get());
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticStringField(
              "android/os/Build", "PRODUCT", mProduct)) {
        mAdapterDescription.AppendPrintf(
            ", Product: %s", NS_LossyConvertUTF16toASCII(mProduct).get());
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticStringField(
              "android/os/Build", "MANUFACTURER", mManufacturer)) {
        mAdapterDescription.AppendPrintf(
            ", Manufacturer: %s", NS_LossyConvertUTF16toASCII(mManufacturer).get());
      }

      if (mozilla::AndroidBridge::Bridge()->GetStaticIntField(
              "android/os/Build$VERSION", "SDK_INT", &mSDKVersion)) {
        // the HARDWARE field isn't available on Android SDK < 8, but we require 9+
        // anyway.
        MOZ_ASSERT(mSDKVersion >= 8);
        if (mozilla::AndroidBridge::Bridge()->GetStaticStringField(
                "android/os/Build", "HARDWARE", mHardware)) {
          mAdapterDescription.AppendPrintf(
              ", Hardware: %s", NS_LossyConvertUTF16toASCII(mHardware).get());
        }
      } else {
        mSDKVersion = 0;
      }

      nsString release;
      mozilla::AndroidBridge::Bridge()->GetStaticStringField(
          "android/os/Build$VERSION", "RELEASE", release);
      mOSVersion = NS_LossyConvertUTF16toASCII(release);

      mOSVersionInteger = 0;
      char a[5], b[5], c[5], d[5];
      SplitDriverVersion(mOSVersion.get(), a, b, c, d);
      uint8_t na = atoi(a);
      uint8_t nb = atoi(b);
      uint8_t nc = atoi(c);
      uint8_t nd = atoi(d);

      mOSVersionInteger = (uint32_t(na) << 24) | (uint32_t(nb) << 16) |
                          (uint32_t(nc) << 8) | uint32_t(nd);

      mAdapterDescription.AppendPrintf(
          ", OpenGL: %s -- %s -- %s", mGLStrings->Vendor().get(),
          mGLStrings->Renderer().get(), mGLStrings->Version().get());

      AddCrashReportAnnotations();

      mScreenInfo.mScreenDimensions =
          mozilla::AndroidBridge::Bridge()->getScreenSize();

      mInitialized = true;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDescription(nsAString& aAdapterDescription) {
      EnsureInitialized();
      aAdapterDescription = NS_ConvertASCIItoUTF16(mAdapterDescription);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDescription2(nsAString& aAdapterDescription) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterRAM(uint32_t* aAdapterRAM) {
      EnsureInitialized();
      *aAdapterRAM = 0;
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterRAM2(uint32_t* aAdapterRAM) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriver(nsAString& aAdapterDriver) {
      EnsureInitialized();
      aAdapterDriver.Truncate();
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriver2(nsAString& aAdapterDriver) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVendor(nsAString& aAdapterDriverVendor) {
      EnsureInitialized();
      aAdapterDriverVendor.Truncate();
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVendor2(nsAString& aAdapterDriverVendor) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVersion(nsAString& aAdapterDriverVersion) {
      EnsureInitialized();
      aAdapterDriverVersion = NS_ConvertASCIItoUTF16(mGLStrings->Version());
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverVersion2(nsAString& aAdapterDriverVersion) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverDate(nsAString& aAdapterDriverDate) {
      EnsureInitialized();
      aAdapterDriverDate.Truncate();
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDriverDate2(nsAString& aAdapterDriverDate) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterVendorID(nsAString& aAdapterVendorID) {
      EnsureInitialized();
      aAdapterVendorID = NS_ConvertASCIItoUTF16(mGLStrings->Vendor());
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterVendorID2(nsAString& aAdapterVendorID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDeviceID(nsAString& aAdapterDeviceID) {
      EnsureInitialized();
      aAdapterDeviceID = NS_ConvertASCIItoUTF16(mGLStrings->Renderer());
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterDeviceID2(nsAString& aAdapterDeviceID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterSubsysID(nsAString& aAdapterSubsysID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetAdapterSubsysID2(nsAString& aAdapterSubsysID) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active) {
      EnsureInitialized();
      return NS_ERROR_FAILURE;
    }

    NS_IMETHODIMP
    GfxInfo::GetDisplayInfo(nsTArray& aDisplayInfo) {
      EnsureInitialized();
      nsString displayInfo;
      displayInfo.AppendPrintf("%dx%d",
                               (int32_t)mScreenInfo.mScreenDimensions.width,
                               (int32_t)mScreenInfo.mScreenDimensions.height);
      aDisplayInfo.AppendElement(displayInfo);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetDisplayWidth(nsTArray& aDisplayWidth) {
      aDisplayWidth.AppendElement((uint32_t)mScreenInfo.mScreenDimensions.width);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetDisplayHeight(nsTArray& aDisplayHeight) {
      aDisplayHeight.AppendElement((uint32_t)mScreenInfo.mScreenDimensions.height);
      return NS_OK;
    }

    NS_IMETHODIMP
    GfxInfo::GetDrmRenderDevice(nsACString& aDrmRenderDevice) {
      return NS_ERROR_NOT_IMPLEMENTED;
    }

    void GfxInfo::AddCrashReportAnnotations() {
      CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterVendorID,
                                         mGLStrings->Vendor());
      CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::AdapterDeviceID,
                                         mGLStrings->Renderer());
      CrashReporter::AnnotateCrashReport(
          CrashReporter::Annotation::AdapterDriverVersion, mGLStrings->Version());
    }

    const nsTArray& GfxInfo::GetGfxDriverInfo() {
      if (sDriverInfo->IsEmpty()) {
        APPEND_TO_DRIVER_BLOCKLIST2(
            OperatingSystem::Android, DeviceFamily::All,
            nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_STATUS_OK,
            DRIVER_COMPARISON_IGNORED, GfxDriverInfo::allDriverVersions,
            "FEATURE_OK_FORCE_OPENGL");
      }

      return *sDriverInfo;
    }

    nsresult GfxInfo::GetFeatureStatusImpl(
        int32_t aFeature, int32_t* aStatus, nsAString& aSuggestedDriverVersion,
        const nsTArray& aDriverInfo, nsACString& aFailureId,
        OperatingSystem* aOS /* = nullptr */) {
      NS_ENSURE_ARG_POINTER(aStatus);
      aSuggestedDriverVersion.SetIsVoid(true);
      *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
      OperatingSystem os = mOS;
      if (aOS) *aOS = os;

      if (sShutdownOccurred) {
        return NS_OK;
      }

      // OpenGL layers are never blocklisted on Android.
      // This early return is so we avoid potentially slow
      // GLStrings initialization on startup when we initialize GL layers.
      if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS) {
        *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
        return NS_OK;
      }

      EnsureInitialized();

      if (mGLStrings->Vendor().IsEmpty() || mGLStrings->Renderer().IsEmpty()) {
        *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
        return NS_OK;
      }

      // Don't evaluate special cases when evaluating the downloaded blocklist.
      if (aDriverInfo.IsEmpty()) {
        if (aFeature == nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION) {
          if (mSDKVersion < 11) {
            // It's slower than software due to not having a compositing fast path
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
            aFailureId = "FEATURE_FAILURE_CANVAS_2D_SDK";
          } else if (mGLStrings->Renderer().Find("Vivante GC1000") != -1) {
            // Blocklist Vivante GC1000. See bug 1248183.
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILED_CANVAS_2D_HW";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBGL_OPENGL) {
          if (mGLStrings->Renderer().Find("Adreno 200") != -1 ||
              mGLStrings->Renderer().Find("Adreno 205") != -1) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_ADRENO_20x";
            return NS_OK;
          }

          if (mSDKVersion <= 17) {
            if (mGLStrings->Renderer().Find("Adreno (TM) 3") != -1) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_ADRENO_3xx";
            }
            return NS_OK;
          }

          if (mHardware.EqualsLiteral("ville")) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_VILLE";
            return NS_OK;
          }
        }

        if (aFeature == FEATURE_STAGEFRIGHT) {
          NS_LossyConvertUTF16toASCII cManufacturer(mManufacturer);
          NS_LossyConvertUTF16toASCII cModel(mModel);
          NS_LossyConvertUTF16toASCII cHardware(mHardware);

          if (cHardware.EqualsLiteral("antares") ||
              cHardware.EqualsLiteral("harmony") ||
              cHardware.EqualsLiteral("picasso") ||
              cHardware.EqualsLiteral("picasso_e") ||
              cHardware.EqualsLiteral("ventana") ||
              cHardware.EqualsLiteral("rk30board")) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_STAGE_HW";
            return NS_OK;
          }

          if (CompareVersions(mOSVersion.get(), "4.1.0") < 0) {
            // Whitelist:
            //   All Samsung ICS devices, except for:
            //     Samsung SGH-I717 (Bug 845729)
            //     Samsung SGH-I727 (Bug 845729)
            //     Samsung SGH-I757 (Bug 845729)
            //   All Galaxy nexus ICS devices
            //   Sony Xperia Ion (LT28) ICS devices
            bool isWhitelisted =
                cModel.Equals("LT28h", nsCaseInsensitiveCStringComparator) ||
                cManufacturer.Equals("samsung",
                                     nsCaseInsensitiveCStringComparator) ||
                cModel.Equals(
                    "galaxy nexus",
                    nsCaseInsensitiveCStringComparator);  // some Galaxy Nexus
                                                          // have
                                                          // manufacturer=amazon

            if (cModel.Find("SGH-I717", true) != -1 ||
                cModel.Find("SGH-I727", true) != -1 ||
                cModel.Find("SGH-I757", true) != -1) {
              isWhitelisted = false;
            }

            if (!isWhitelisted) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_4_1_HW";
              return NS_OK;
            }
          } else if (CompareVersions(mOSVersion.get(), "4.2.0") < 0) {
            // Whitelist:
            //   All JB phones except for those in blocklist below
            // Blocklist:
            //   Samsung devices from bug 812881 and 853522.
            //   Motorola XT890 from bug 882342.
            bool isBlocklisted = cModel.Find("GT-P3100", true) != -1 ||
                                 cModel.Find("GT-P3110", true) != -1 ||
                                 cModel.Find("GT-P3113", true) != -1 ||
                                 cModel.Find("GT-P5100", true) != -1 ||
                                 cModel.Find("GT-P5110", true) != -1 ||
                                 cModel.Find("GT-P5113", true) != -1 ||
                                 cModel.Find("XT890", true) != -1;

            if (isBlocklisted) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_4_2_HW";
              return NS_OK;
            }
          } else if (CompareVersions(mOSVersion.get(), "4.3.0") < 0) {
            // Blocklist all Sony devices
            if (cManufacturer.Find("Sony", true) != -1) {
              *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
              aFailureId = "FEATURE_FAILURE_4_3_SONY";
              return NS_OK;
            }
          }
        }

        if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_ENCODE) {
          if (mozilla::AndroidBridge::Bridge()) {
            *aStatus = WebRtcHwVp8EncodeSupported();
            aFailureId = "FEATURE_FAILURE_WEBRTC_ENCODE";
            return NS_OK;
          }
        }
        if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_DECODE) {
          if (mozilla::AndroidBridge::Bridge()) {
            *aStatus = WebRtcHwVp8DecodeSupported();
            aFailureId = "FEATURE_FAILURE_WEBRTC_DECODE";
            return NS_OK;
          }
        }
        if (aFeature == FEATURE_WEBRTC_HW_ACCELERATION_H264) {
          if (mozilla::AndroidBridge::Bridge()) {
            *aStatus = WebRtcHwH264Supported();
            aFailureId = "FEATURE_FAILURE_WEBRTC_H264";
            return NS_OK;
          }
        }
        if (aFeature == FEATURE_VP8_HW_DECODE ||
            aFeature == FEATURE_VP9_HW_DECODE) {
          NS_LossyConvertUTF16toASCII model(mModel);
          bool isBlocked =
              // GIFV crash, see bug 1232911.
              model.Equals("GT-N8013", nsCaseInsensitiveCStringComparator);

          if (isBlocked) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_VPx";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBRENDER) {
          bool isUnblocked = false;
          const nsCString& gpu = mGLStrings->Renderer();
          NS_LossyConvertUTF16toASCII model(mModel);

    #ifdef NIGHTLY_BUILD
          // On Nightly enable Webrender on all Adreno 4xx GPUs
          isUnblocked |= gpu.Find("Adreno (TM) 4", /*ignoreCase*/ true) >= 0;
    #endif
          // Enable Webrender on all Adreno 5xx and 6xx GPUs
          isUnblocked |= gpu.Find("Adreno (TM) 5", /*ignoreCase*/ true) >= 0 ||
                         gpu.Find("Adreno (TM) 6", /*ignoreCase*/ true) >= 0;

          // Enable Webrender on all Mali-Txxx GPUs
          isUnblocked |= gpu.Find("Mali-T", /*ignoreCase*/ true) >= 0;

          // Enable Webrender on all Mali-Gxx GPUs...
          isUnblocked |= gpu.Find("Mali-G", /*ignoreCase*/ true) >= 0 &&
                         // Excluding G31 due to bug 1689947.
                         gpu.Find("Mali-G31", /*ignoreCase*/ true) == kNotFound;

          // Webrender requires the extension GL_OES_EGL_image_external_essl3
          // to render video. Bug 1507074 tracks removing this requirement.
          bool supportsImageExternalEssl3 = mGLStrings->Extensions().Contains(
              "GL_OES_EGL_image_external_essl3"_ns);

          if (!isUnblocked) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_WEBRENDER_BLOCKED_DEVICE";
          } else if (!supportsImageExternalEssl3) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_WEBRENDER_NO_IMAGE_EXTERNAL";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_ALLOW_QUALIFIED;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBRENDER_SCISSORED_CACHE_CLEARS) {
          // Emulator with SwiftShader is buggy when attempting to clear picture
          // cache textures with a scissor rect set.
          const bool isEmulatorSwiftShader =
              mGLStrings->Renderer().Find(
                  "Android Emulator OpenGL ES Translator (Google SwiftShader)") >=
              0;
          if (isEmulatorSwiftShader) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_BUG_1603515";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }

        if (aFeature == FEATURE_WEBRENDER_OPTIMIZED_SHADERS) {
          // Optimized shaders result in completely broken rendering in at least one
          // Mali-T6xx device. Disable on all T6xx as a precaution until we know
          // more specifically which devices are affected. See bug 1689064 for
          // details.
          const bool isMaliT6xx =
              mGLStrings->Renderer().Find("Mali-T6", /*ignoreCase*/ true) >= 0;
          if (isMaliT6xx) {
            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
            aFailureId = "FEATURE_FAILURE_BUG_1689064";
          } else {
            *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
          }
          return NS_OK;
        }
      }

      return GfxInfoBase::GetFeatureStatusImpl(
          aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, aFailureId, &os);
    }

    static nsCString FeatureCacheOsVerPrefName(int32_t aFeature) {
      nsCString osPrefName;
      osPrefName.AppendASCII("gfxinfo.cache.");
      osPrefName.AppendInt(aFeature);
      osPrefName.AppendASCII(".osver");
      return osPrefName;
    }

    static nsCString FeatureCacheValuePrefName(int32_t aFeature) {
      nsCString osPrefName;
      osPrefName.AppendASCII("gfxinfo.cache.");
      osPrefName.AppendInt(aFeature);
      osPrefName.AppendASCII(".value");
      return osPrefName;
    }

    static bool GetCachedFeatureVal(int32_t aFeature, uint32_t aExpectedOsVer,
                                    int32_t& aOutStatus) {
      uint32_t osVer = 0;
      nsresult rv =
          Preferences::GetUint(FeatureCacheOsVerPrefName(aFeature).get(), &osVer);
      if (NS_FAILED(rv) || osVer != aExpectedOsVer) {
        return false;
      }
      int32_t status = 0;
      rv = Preferences::GetInt(FeatureCacheValuePrefName(aFeature).get(), &status);
      if (NS_FAILED(rv)) {
        return false;
      }
      aOutStatus = status;
      return true;
    }

    static void SetCachedFeatureVal(int32_t aFeature, uint32_t aOsVer,
                                    int32_t aStatus) {
      // Ignore failures; not much we can do anyway.
      Preferences::SetUint(FeatureCacheOsVerPrefName(aFeature).get(), aOsVer);
      Preferences::SetInt(FeatureCacheValuePrefName(aFeature).get(), aStatus);
    }

    int32_t GfxInfo::WebRtcHwVp8EncodeSupported() {
      MOZ_ASSERT(mozilla::AndroidBridge::Bridge());

      // The Android side of this calculation is very slow, so we cache the result
      // in preferences, invalidating if the OS version changes.

      int32_t status = 0;
      if (GetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_ENCODE,
                              mOSVersionInteger, status)) {
        return status;
      }

      status = mozilla::AndroidBridge::Bridge()->HasHWVP8Encoder()
                   ? nsIGfxInfo::FEATURE_STATUS_OK
                   : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      SetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_ENCODE, mOSVersionInteger,
                          status);

      return status;
    }

    int32_t GfxInfo::WebRtcHwVp8DecodeSupported() {
      MOZ_ASSERT(mozilla::AndroidBridge::Bridge());

      // The Android side of this caclulation is very slow, so we cache the result
      // in preferences, invalidating if the OS version changes.

      int32_t status = 0;
      if (GetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_DECODE,
                              mOSVersionInteger, status)) {
        return status;
      }

      status = mozilla::AndroidBridge::Bridge()->HasHWVP8Decoder()
                   ? nsIGfxInfo::FEATURE_STATUS_OK
                   : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      SetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_DECODE, mOSVersionInteger,
                          status);

      return status;
    }

    int32_t GfxInfo::WebRtcHwH264Supported() {
      MOZ_ASSERT(mozilla::AndroidBridge::Bridge());

      // The Android side of this calculation is very slow, so we cache the result
      // in preferences, invalidating if the OS version changes.

      int32_t status = 0;
      if (GetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_H264,
                              mOSVersionInteger, status)) {
        return status;
      }

      status = mozilla::AndroidBridge::Bridge()->HasHWH264()
                   ? nsIGfxInfo::FEATURE_STATUS_OK
                   : nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      SetCachedFeatureVal(FEATURE_WEBRTC_HW_ACCELERATION_H264, mOSVersionInteger,
                          status);

      return status;
    }

    #ifdef DEBUG

    // Implement nsIGfxInfoDebug

    NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString& aVendorID) {
      mGLStrings->SpoofVendor(NS_LossyConvertUTF16toASCII(aVendorID));
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString& aDeviceID) {
      mGLStrings->SpoofRenderer(NS_LossyConvertUTF16toASCII(aDeviceID));
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString& aDriverVersion) {
      mGLStrings->SpoofVersion(NS_LossyConvertUTF16toASCII(aDriverVersion));
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::SpoofOSVersion(uint32_t aVersion) {
      EnsureInitialized();
      mOSVersion = aVersion;
      return NS_OK;
    }

    NS_IMETHODIMP GfxInfo::FireTestProcess() { return NS_OK; }

    #endif

    nsString GfxInfo::Model() {
      EnsureInitialized();
      return mModel;
    }

    nsString GfxInfo::Hardware() {
      EnsureInitialized();
      return mHardware;
    }

    nsString GfxInfo::Product() {
      EnsureInitialized();
      return mProduct;
    }

    nsString GfxInfo::Manufacturer() {
      EnsureInitialized();
      return mManufacturer;
    }

    uint32_t GfxInfo::OperatingSystemVersion() {
      EnsureInitialized();
      return mOSVersionInteger;
    }

    }  // namespace widget