The Tor Browser: widget/xpwidgets/GfxInfoBase.cpp@6474c204b198 (annotated)

widget/xpwidgets/GfxInfoBase.cpp@6474c204b198 (annotated)

widget/xpwidgets/GfxInfoBase.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* vim: se cin sw=2 ts=2 et : */
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozilla/ArrayUtils.h"
 #include "GfxInfoBase.h"
 #include "GfxInfoWebGL.h"
 #include "GfxDriverInfo.h"
 #include "nsCOMPtr.h"
 #include "nsCOMArray.h"
 #include "nsAutoPtr.h"
 #include "nsString.h"
 #include "nsUnicharUtils.h"
 #include "mozilla/Services.h"
 #include "mozilla/Observer.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMHTMLCollection.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMNodeList.h"
 #include "nsTArray.h"
 #include "nsXULAppAPI.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/ContentChild.h"
 #if defined(MOZ_CRASHREPORTER)
 #include "nsExceptionHandler.h"
 #endif
 using namespace mozilla::widget;
 using namespace mozilla;
 using mozilla::MutexAutoLock;
 nsTArray<GfxDriverInfo>* GfxInfoBase::mDriverInfo;
 bool GfxInfoBase::mDriverInfoObserverInitialized;
 // Observes for shutdown so that the child GfxDriverInfo list is freed.
 class ShutdownObserver : public nsIObserver
 {
 public:
   ShutdownObserver() {}
   virtual ~ShutdownObserver() {}
   NS_DECL_ISUPPORTS
   NS_IMETHOD Observe(nsISupports *subject, const char *aTopic,
                      const char16_t *aData)
   {
     MOZ_ASSERT(strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0);
     delete GfxInfoBase::mDriverInfo;
     GfxInfoBase::mDriverInfo = nullptr;
     for (uint32_t i = 0; i < DeviceFamilyMax; i++)
       delete GfxDriverInfo::mDeviceFamilies[i];
     for (uint32_t i = 0; i < DeviceVendorMax; i++)
       delete GfxDriverInfo::mDeviceVendors[i];
     return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(ShutdownObserver, nsIObserver)
 void InitGfxDriverInfoShutdownObserver()
 {
   if (GfxInfoBase::mDriverInfoObserverInitialized)
     return;
   GfxInfoBase::mDriverInfoObserverInitialized = true;
   nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
   if (!observerService) {
     NS_WARNING("Could not get observer service!");
     return;
   }
   ShutdownObserver *obs = new ShutdownObserver();
   observerService->AddObserver(obs, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
 }
 using namespace mozilla::widget;
 using namespace mozilla;
 NS_IMPL_ISUPPORTS(GfxInfoBase, nsIGfxInfo, nsIObserver, nsISupportsWeakReference)
 #define BLACKLIST_PREF_BRANCH "gfx.blacklist."
 #define SUGGESTED_VERSION_PREF BLACKLIST_PREF_BRANCH "suggested-driver-version"
 #define BLACKLIST_ENTRY_TAG_NAME "gfxBlacklistEntry"
 static const char*
 GetPrefNameForFeature(int32_t aFeature)
 {
   const char* name = nullptr;
   switch(aFeature) {
     case nsIGfxInfo::FEATURE_DIRECT2D:
       name = BLACKLIST_PREF_BRANCH "direct2d";
       break;
     case nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS:
       name = BLACKLIST_PREF_BRANCH "layers.direct3d9";
       break;
     case nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS:
       name = BLACKLIST_PREF_BRANCH "layers.direct3d10";
       break;
     case nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS:
       name = BLACKLIST_PREF_BRANCH "layers.direct3d10-1";
       break;
     case nsIGfxInfo::FEATURE_OPENGL_LAYERS:
       name = BLACKLIST_PREF_BRANCH "layers.opengl";
       break;
     case nsIGfxInfo::FEATURE_WEBGL_OPENGL:
       name = BLACKLIST_PREF_BRANCH "webgl.opengl";
       break;
     case nsIGfxInfo::FEATURE_WEBGL_ANGLE:
       name = BLACKLIST_PREF_BRANCH "webgl.angle";
       break;
     case nsIGfxInfo::FEATURE_WEBGL_MSAA:
       name = BLACKLIST_PREF_BRANCH "webgl.msaa";
       break;
     case nsIGfxInfo::FEATURE_STAGEFRIGHT:
       name = BLACKLIST_PREF_BRANCH "stagefright";
       break;
     default:
       break;
   };
   return name;
 }
 // Returns the value of the pref for the relevant feature in aValue.
 // If the pref doesn't exist, aValue is not touched, and returns false.
 static bool
 GetPrefValueForFeature(int32_t aFeature, int32_t& aValue)
 {
   const char *prefname = GetPrefNameForFeature(aFeature);
   if (!prefname)
     return false;
   aValue = false;
   return NS_SUCCEEDED(Preferences::GetInt(prefname, &aValue));
 }
 static void
 SetPrefValueForFeature(int32_t aFeature, int32_t aValue)
 {
   const char *prefname = GetPrefNameForFeature(aFeature);
   if (!prefname)
     return;
   Preferences::SetInt(prefname, aValue);
 }
 static void
 RemovePrefForFeature(int32_t aFeature)
 {
   const char *prefname = GetPrefNameForFeature(aFeature);
   if (!prefname)
     return;
   Preferences::ClearUser(prefname);
 }
 static bool
 GetPrefValueForDriverVersion(nsCString& aVersion)
 {
   return NS_SUCCEEDED(Preferences::GetCString(SUGGESTED_VERSION_PREF,
                                               &aVersion));
 }
 static void
 SetPrefValueForDriverVersion(const nsAString& aVersion)
 {
   Preferences::SetString(SUGGESTED_VERSION_PREF, aVersion);
 }
 static void
 RemovePrefForDriverVersion()
 {
   Preferences::ClearUser(SUGGESTED_VERSION_PREF);
 }
 // <foo>Hello</foo> - "Hello" is stored as a child text node of the foo node.
 static bool
 BlacklistNodeToTextValue(nsIDOMNode *aBlacklistNode, nsAString& aValue)
 {
   nsAutoString value;
   if (NS_FAILED(aBlacklistNode->GetTextContent(value)))
     return false;
   value.Trim(" \t\r\n");
   aValue = value;
   return true;
 }
 static OperatingSystem
 BlacklistOSToOperatingSystem(const nsAString& os)
 {
   if (os == NS_LITERAL_STRING("WINNT 5.1"))
     return DRIVER_OS_WINDOWS_XP;
   else if (os == NS_LITERAL_STRING("WINNT 5.2"))
     return DRIVER_OS_WINDOWS_SERVER_2003;
   else if (os == NS_LITERAL_STRING("WINNT 6.0"))
     return DRIVER_OS_WINDOWS_VISTA;
   else if (os == NS_LITERAL_STRING("WINNT 6.1"))
     return DRIVER_OS_WINDOWS_7;
   else if (os == NS_LITERAL_STRING("WINNT 6.2"))
     return DRIVER_OS_WINDOWS_8;
   else if (os == NS_LITERAL_STRING("WINNT 6.3"))
     return DRIVER_OS_WINDOWS_8_1;
   else if (os == NS_LITERAL_STRING("Linux"))
     return DRIVER_OS_LINUX;
   else if (os == NS_LITERAL_STRING("Darwin 9"))
     return DRIVER_OS_OS_X_10_5;
   else if (os == NS_LITERAL_STRING("Darwin 10"))
     return DRIVER_OS_OS_X_10_6;
   else if (os == NS_LITERAL_STRING("Darwin 11"))
     return DRIVER_OS_OS_X_10_7;
   else if (os == NS_LITERAL_STRING("Darwin 12"))
     return DRIVER_OS_OS_X_10_8;
   else if (os == NS_LITERAL_STRING("Android"))
     return DRIVER_OS_ANDROID;
   else if (os == NS_LITERAL_STRING("All"))
     return DRIVER_OS_ALL;
   return DRIVER_OS_UNKNOWN;
 }
 static GfxDeviceFamily*
 BlacklistDevicesToDeviceFamily(nsIDOMHTMLCollection* aDevices)
 {
   uint32_t length;
   if (NS_FAILED(aDevices->GetLength(&length)))
     return nullptr;
   // For each <device>, get its device ID, and return a freshly-allocated
   // GfxDeviceFamily with the contents of that array.
   GfxDeviceFamily* deviceIds = new GfxDeviceFamily;
   for (uint32_t i = 0; i < length; ++i) {
     nsCOMPtr<nsIDOMNode> node;
     if (NS_FAILED(aDevices->Item(i, getter_AddRefs(node))) || !node)
       continue;
     nsAutoString deviceValue;
     if (!BlacklistNodeToTextValue(node, deviceValue))
       continue;
     deviceIds->AppendElement(deviceValue);
   }
   return deviceIds;
 }
 static int32_t
 BlacklistFeatureToGfxFeature(const nsAString& aFeature)
 {
   if (aFeature == NS_LITERAL_STRING("DIRECT2D"))
     return nsIGfxInfo::FEATURE_DIRECT2D;
   else if (aFeature == NS_LITERAL_STRING("DIRECT3D_9_LAYERS"))
     return nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS;
   else if (aFeature == NS_LITERAL_STRING("DIRECT3D_10_LAYERS"))
     return nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS;
   else if (aFeature == NS_LITERAL_STRING("DIRECT3D_10_1_LAYERS"))
     return nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS;
   else if (aFeature == NS_LITERAL_STRING("OPENGL_LAYERS"))
     return nsIGfxInfo::FEATURE_OPENGL_LAYERS;
   else if (aFeature == NS_LITERAL_STRING("WEBGL_OPENGL"))
     return nsIGfxInfo::FEATURE_WEBGL_OPENGL;
   else if (aFeature == NS_LITERAL_STRING("WEBGL_ANGLE"))
     return nsIGfxInfo::FEATURE_WEBGL_ANGLE;
   else if (aFeature == NS_LITERAL_STRING("WEBGL_MSAA"))
     return nsIGfxInfo::FEATURE_WEBGL_MSAA;
   else if (aFeature == NS_LITERAL_STRING("STAGEFRIGHT"))
     return nsIGfxInfo::FEATURE_STAGEFRIGHT;
   return 0;
 }
 static int32_t
 BlacklistFeatureStatusToGfxFeatureStatus(const nsAString& aStatus)
 {
   if (aStatus == NS_LITERAL_STRING("NO_INFO"))
     return nsIGfxInfo::FEATURE_NO_INFO;
   else if (aStatus == NS_LITERAL_STRING("BLOCKED_DRIVER_VERSION"))
     return nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
   else if (aStatus == NS_LITERAL_STRING("BLOCKED_DEVICE"))
     return nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
   else if (aStatus == NS_LITERAL_STRING("DISCOURAGED"))
     return nsIGfxInfo::FEATURE_DISCOURAGED;
   else if (aStatus == NS_LITERAL_STRING("BLOCKED_OS_VERSION"))
     return nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
   // Do not allow it to set STATUS_UNKNOWN.
   return nsIGfxInfo::FEATURE_NO_INFO;
 }
 static VersionComparisonOp
 BlacklistComparatorToComparisonOp(const nsAString& op)
 {
   if (op == NS_LITERAL_STRING("LESS_THAN"))
     return DRIVER_LESS_THAN;
   else if (op == NS_LITERAL_STRING("LESS_THAN_OR_EQUAL"))
     return DRIVER_LESS_THAN_OR_EQUAL;
   else if (op == NS_LITERAL_STRING("GREATER_THAN"))
     return DRIVER_GREATER_THAN;
   else if (op == NS_LITERAL_STRING("GREATER_THAN_OR_EQUAL"))
     return DRIVER_GREATER_THAN_OR_EQUAL;
   else if (op == NS_LITERAL_STRING("EQUAL"))
     return DRIVER_EQUAL;
   else if (op == NS_LITERAL_STRING("NOT_EQUAL"))
     return DRIVER_NOT_EQUAL;
   else if (op == NS_LITERAL_STRING("BETWEEN_EXCLUSIVE"))
     return DRIVER_BETWEEN_EXCLUSIVE;
   else if (op == NS_LITERAL_STRING("BETWEEN_INCLUSIVE"))
     return DRIVER_BETWEEN_INCLUSIVE;
   else if (op == NS_LITERAL_STRING("BETWEEN_INCLUSIVE_START"))
     return DRIVER_BETWEEN_INCLUSIVE_START;
   return DRIVER_COMPARISON_IGNORED;
 }
 // Arbitrarily returns the first |tagname| child of |element|.
 static bool
 BlacklistNodeGetChildByName(nsIDOMElement *element,
                             const nsAString& tagname,
                             nsIDOMNode** firstchild)
 {
   nsCOMPtr<nsIDOMHTMLCollection> nodelist;
   if (NS_FAILED(element->GetElementsByTagName(tagname,
                                               getter_AddRefs(nodelist))) ||
       !nodelist) {
     return false;
   }
   nsCOMPtr<nsIDOMNode> node;
   if (NS_FAILED(nodelist->Item(0, getter_AddRefs(node))) || !node)
     return false;
   node.forget(firstchild);
   return true;
 }
 /*
 <gfxBlacklistEntry>
   <os>WINNT 6.0</os>
   <vendor>0x8086</vendor>
   <devices>
     <device>0x2582</device>
     <device>0x2782</device>
   </devices>
   <feature> DIRECT3D_10_LAYERS </feature>
   <featureStatus> BLOCKED_DRIVER_VERSION </featureStatus>
   <driverVersion> 8.52.322.2202 </driverVersion>
   <driverVersionComparator> LESS_THAN_OR_EQUAL </driverVersionComparator>
 </gfxBlacklistEntry>
 */
 static bool
 BlacklistEntryToDriverInfo(nsIDOMNode* aBlacklistEntry,
                            GfxDriverInfo& aDriverInfo)
 {
   nsAutoString nodename;
   if (NS_FAILED(aBlacklistEntry->GetNodeName(nodename)) ||
       nodename != NS_LITERAL_STRING(BLACKLIST_ENTRY_TAG_NAME)) {
     return false;
   }
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aBlacklistEntry);
   if (!element)
     return false;
   nsCOMPtr<nsIDOMNode> dataNode;
   nsAutoString dataValue;
   // <os>WINNT 6.0</os>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("os"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mOperatingSystem = BlacklistOSToOperatingSystem(dataValue);
   }
   // <osversion>14</osversion> currently only used for Android
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("osversion"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mOperatingSystemVersion = strtoul(NS_LossyConvertUTF16toASCII(dataValue).get(),
                                                   nullptr, 10);
   }
   // <vendor>0x8086</vendor>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("vendor"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mAdapterVendor = dataValue;
   }
   // <devices>
   //   <device>0x2582</device>
   //   <device>0x2782</device>
   // </devices>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("devices"),
                                   getter_AddRefs(dataNode))) {
     nsCOMPtr<nsIDOMElement> devicesElement = do_QueryInterface(dataNode);
     if (devicesElement) {
       // Get only the <device> nodes, because BlacklistDevicesToDeviceFamily
       // assumes it is passed no other nodes.
       nsCOMPtr<nsIDOMHTMLCollection> devices;
       if (NS_SUCCEEDED(devicesElement->GetElementsByTagName(NS_LITERAL_STRING("device"),
                                                             getter_AddRefs(devices)))) {
         GfxDeviceFamily* deviceIds = BlacklistDevicesToDeviceFamily(devices);
         if (deviceIds) {
           // Get GfxDriverInfo to adopt the devices array we created.
           aDriverInfo.mDeleteDevices = true;
           aDriverInfo.mDevices = deviceIds;
         }
       }
     }
   }
   // <feature> DIRECT3D_10_LAYERS </feature>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("feature"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mFeature = BlacklistFeatureToGfxFeature(dataValue);
   }
   // <featureStatus> BLOCKED_DRIVER_VERSION </featureStatus>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("featureStatus"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mFeatureStatus = BlacklistFeatureStatusToGfxFeatureStatus(dataValue);
   }
   // <driverVersion> 8.52.322.2202 </driverVersion>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("driverVersion"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     uint64_t version;
     if (ParseDriverVersion(dataValue, &version))
       aDriverInfo.mDriverVersion = version;
   }
   // <driverVersionComparator> LESS_THAN_OR_EQUAL </driverVersionComparator>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("driverVersionComparator"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mComparisonOp = BlacklistComparatorToComparisonOp(dataValue);
   }
   // <model>foo</model>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("model"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mModel = dataValue;
   }
   // <product>foo</product>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("product"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mProduct = dataValue;
   }
   // <manufacturer>foo</manufacturer>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("manufacturer"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mManufacturer = dataValue;
   }
   // <hardware>foo</hardware>
   if (BlacklistNodeGetChildByName(element, NS_LITERAL_STRING("hardware"),
                                   getter_AddRefs(dataNode))) {
     BlacklistNodeToTextValue(dataNode, dataValue);
     aDriverInfo.mHardware = dataValue;
   }
   // We explicitly ignore unknown elements.
   return true;
 }
 static void
 BlacklistEntriesToDriverInfo(nsIDOMHTMLCollection* aBlacklistEntries,
                              nsTArray<GfxDriverInfo>& aDriverInfo)
 {
   uint32_t length;
   if (NS_FAILED(aBlacklistEntries->GetLength(&length)))
     return;
   aDriverInfo.Clear();
   aDriverInfo.SetLength(length);
   for (uint32_t i = 0; i < length; ++i) {
     nsCOMPtr<nsIDOMNode> blacklistEntry;
     if (NS_SUCCEEDED(aBlacklistEntries->Item(i,
                                              getter_AddRefs(blacklistEntry))) &&
         blacklistEntry) {
       GfxDriverInfo di;
       if (BlacklistEntryToDriverInfo(blacklistEntry, di)) {
         aDriverInfo[i] = di;
       }
       // Prevent di falling out of scope from destroying the devices.
       di.mDeleteDevices = false;
     }
   }
 }
 NS_IMETHODIMP
 GfxInfoBase::Observe(nsISupports* aSubject, const char* aTopic,
                      const char16_t* aData)
 {
   if (strcmp(aTopic, "blocklist-data-gfxItems") == 0) {
     nsCOMPtr<nsIDOMElement> gfxItems = do_QueryInterface(aSubject);
     if (gfxItems) {
       nsCOMPtr<nsIDOMHTMLCollection> blacklistEntries;
       if (NS_SUCCEEDED(gfxItems->
             GetElementsByTagName(NS_LITERAL_STRING(BLACKLIST_ENTRY_TAG_NAME),
                                  getter_AddRefs(blacklistEntries))) &&
           blacklistEntries)
       {
         nsTArray<GfxDriverInfo> driverInfo;
         BlacklistEntriesToDriverInfo(blacklistEntries, driverInfo);
         EvaluateDownloadedBlacklist(driverInfo);
       }
     }
   }
   return NS_OK;
 }
 GfxInfoBase::GfxInfoBase()
     : mFailureCount(0)
     , mMutex("GfxInfoBase")
 {
 }
 GfxInfoBase::~GfxInfoBase()
 {
 }
 nsresult
 GfxInfoBase::Init()
 {
   InitGfxDriverInfoShutdownObserver();
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   if (os) {
     os->AddObserver(this, "blocklist-data-gfxItems", true);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 GfxInfoBase::GetFeatureStatus(int32_t aFeature, int32_t* aStatus)
 {
   if (GetPrefValueForFeature(aFeature, *aStatus))
     return NS_OK;
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
       // Delegate to the parent process.
       mozilla::dom::ContentChild* cc = mozilla::dom::ContentChild::GetSingleton();
       bool success;
       cc->SendGetGraphicsFeatureStatus(aFeature, aStatus, &success);
       return success ? NS_OK : NS_ERROR_FAILURE;
   }
   nsString version;
   nsTArray<GfxDriverInfo> driverInfo;
   return GetFeatureStatusImpl(aFeature, aStatus, version, driverInfo);
 }
 int32_t
 GfxInfoBase::FindBlocklistedDeviceInList(const nsTArray<GfxDriverInfo>& info,
                                          nsAString& aSuggestedVersion,
                                          int32_t aFeature,
                                          OperatingSystem os)
 {
   int32_t status = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
   nsAutoString adapterVendorID;
   nsAutoString adapterDeviceID;
   nsAutoString adapterDriverVersionString;
   if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) ||
       NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) ||
       NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString)))
   {
     return 0;
   }
 #if defined(XP_WIN) || defined(ANDROID)
   uint64_t driverVersion;
   ParseDriverVersion(adapterDriverVersionString, &driverVersion);
 #endif
   uint32_t i = 0;
   for (; i < info.Length(); i++) {
     if (info[i].mOperatingSystem != DRIVER_OS_ALL &&
         info[i].mOperatingSystem != os)
     {
       continue;
     }
     if (info[i].mOperatingSystemVersion && info[i].mOperatingSystemVersion != OperatingSystemVersion()) {
         continue;
     }
     if (!info[i].mAdapterVendor.Equals(GfxDriverInfo::GetDeviceVendor(VendorAll), nsCaseInsensitiveStringComparator()) &&
         !info[i].mAdapterVendor.Equals(adapterVendorID, nsCaseInsensitiveStringComparator())) {
       continue;
     }
     if (info[i].mDevices != GfxDriverInfo::allDevices && info[i].mDevices->Length()) {
         bool deviceMatches = false;
         for (uint32_t j = 0; j < info[i].mDevices->Length(); j++) {
             if ((*info[i].mDevices)[j].Equals(adapterDeviceID, nsCaseInsensitiveStringComparator())) {
                 deviceMatches = true;
                 break;
             }
         }
         if (!deviceMatches) {
             continue;
         }
     }
     bool match = false;
     if (!info[i].mHardware.IsEmpty() && !info[i].mHardware.Equals(Hardware())) {
         continue;
     }
     if (!info[i].mModel.IsEmpty() && !info[i].mModel.Equals(Model())) {
         continue;
     }
     if (!info[i].mProduct.IsEmpty() && !info[i].mProduct.Equals(Product())) {
         continue;
     }
     if (!info[i].mManufacturer.IsEmpty() && !info[i].mManufacturer.Equals(Manufacturer())) {
         continue;
     }
 #if defined(XP_WIN) || defined(ANDROID)
     switch (info[i].mComparisonOp) {
     case DRIVER_LESS_THAN:
       match = driverVersion < info[i].mDriverVersion;
       break;
     case DRIVER_LESS_THAN_OR_EQUAL:
       match = driverVersion <= info[i].mDriverVersion;
       break;
     case DRIVER_GREATER_THAN:
       match = driverVersion > info[i].mDriverVersion;
       break;
     case DRIVER_GREATER_THAN_OR_EQUAL:
       match = driverVersion >= info[i].mDriverVersion;
       break;
     case DRIVER_EQUAL:
       match = driverVersion == info[i].mDriverVersion;
       break;
     case DRIVER_NOT_EQUAL:
       match = driverVersion != info[i].mDriverVersion;
       break;
     case DRIVER_BETWEEN_EXCLUSIVE:
       match = driverVersion > info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax;
       break;
     case DRIVER_BETWEEN_INCLUSIVE:
       match = driverVersion >= info[i].mDriverVersion && driverVersion <= info[i].mDriverVersionMax;
       break;
     case DRIVER_BETWEEN_INCLUSIVE_START:
       match = driverVersion >= info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax;
       break;
     case DRIVER_COMPARISON_IGNORED:
       // We don't have a comparison op, so we match everything.
       match = true;
       break;
     default:
       NS_WARNING("Bogus op in GfxDriverInfo");
       break;
     }
 #else
     // We don't care what driver version it was. We only check OS version and if
     // the device matches.
     match = true;
 #endif
     if (match || info[i].mDriverVersion == GfxDriverInfo::allDriverVersions) {
       if (info[i].mFeature == GfxDriverInfo::allFeatures ||
           info[i].mFeature == aFeature)
       {
         status = info[i].mFeatureStatus;
         break;
       }
     }
   }
   // Depends on Windows driver versioning. We don't pass a GfxDriverInfo object
   // back to the Windows handler, so we must handle this here.
 #if defined(XP_WIN)
   if (status == FEATURE_BLOCKED_DRIVER_VERSION) {
     if (info[i].mSuggestedVersion) {
         aSuggestedVersion.AppendPrintf("%s", info[i].mSuggestedVersion);
     } else if (info[i].mComparisonOp == DRIVER_LESS_THAN &&
                info[i].mDriverVersion != GfxDriverInfo::allDriverVersions)
     {
         aSuggestedVersion.AppendPrintf("%lld.%lld.%lld.%lld",
                                       (info[i].mDriverVersion & 0xffff000000000000) >> 48,
                                       (info[i].mDriverVersion & 0x0000ffff00000000) >> 32,
                                       (info[i].mDriverVersion & 0x00000000ffff0000) >> 16,
                                       (info[i].mDriverVersion & 0x000000000000ffff));
     }
   }
 #endif
   return status;
 }
 nsresult
 GfxInfoBase::GetFeatureStatusImpl(int32_t aFeature,
                                   int32_t* aStatus,
                                   nsAString& aSuggestedVersion,
                                   const nsTArray<GfxDriverInfo>& aDriverInfo,
                                   OperatingSystem* aOS /* = nullptr */)
 {
   if (*aStatus != nsIGfxInfo::FEATURE_STATUS_UNKNOWN) {
     // Terminate now with the status determined by the derived type (OS-specific
     // code).
     return NS_OK;
   }
   // If an operating system was provided by the derived GetFeatureStatusImpl,
   // grab it here. Otherwise, the OS is unknown.
   OperatingSystem os = DRIVER_OS_UNKNOWN;
   if (aOS)
     os = *aOS;
   nsAutoString adapterVendorID;
   nsAutoString adapterDeviceID;
   nsAutoString adapterDriverVersionString;
   if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) ||
       NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) ||
       NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString)))
   {
     return NS_OK;
   }
   // Check if the device is blocked from the downloaded blocklist. If not, check
   // the static list after that. This order is used so that we can later escape
   // out of static blocks (i.e. if we were wrong or something was patched, we
   // can back out our static block without doing a release).
   int32_t status;
   if (aDriverInfo.Length()) {
     status = FindBlocklistedDeviceInList(aDriverInfo, aSuggestedVersion, aFeature, os);
   } else {
     if (!mDriverInfo) {
       mDriverInfo = new nsTArray<GfxDriverInfo>();
     }
     status = FindBlocklistedDeviceInList(GetGfxDriverInfo(), aSuggestedVersion, aFeature, os);
   }
   // It's now done being processed. It's safe to set the status to NO_INFO.
   if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN) {
     *aStatus = nsIGfxInfo::FEATURE_NO_INFO;
   } else {
     *aStatus = status;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 GfxInfoBase::GetFeatureSuggestedDriverVersion(int32_t aFeature,
                                               nsAString& aVersion)
 {
   nsCString version;
   if (GetPrefValueForDriverVersion(version)) {
     aVersion = NS_ConvertASCIItoUTF16(version);
     return NS_OK;
   }
   int32_t status;
   nsTArray<GfxDriverInfo> driverInfo;
   return GetFeatureStatusImpl(aFeature, &status, aVersion, driverInfo);
 }
 NS_IMETHODIMP
 GfxInfoBase::GetWebGLParameter(const nsAString& aParam,
                                nsAString& aResult)
 {
   return GfxInfoWebGL::GetWebGLParameter(aParam, aResult);
 }
 void
 GfxInfoBase::EvaluateDownloadedBlacklist(nsTArray<GfxDriverInfo>& aDriverInfo)
 {
   int32_t features[] = {
     nsIGfxInfo::FEATURE_DIRECT2D,
     nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS,
     nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS,
     nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS,
     nsIGfxInfo::FEATURE_OPENGL_LAYERS,
     nsIGfxInfo::FEATURE_WEBGL_OPENGL,
     nsIGfxInfo::FEATURE_WEBGL_ANGLE,
     nsIGfxInfo::FEATURE_WEBGL_MSAA,
     nsIGfxInfo::FEATURE_STAGEFRIGHT,
 
   };
   // For every feature we know about, we evaluate whether this blacklist has a
   // non-NO_INFO status. If it does, we set the pref we evaluate in
   // GetFeatureStatus above, so we don't need to hold on to this blacklist
   // anywhere permanent.
   int i = 0;
   while (features[i]) {
     int32_t status;
     nsAutoString suggestedVersion;
     if (NS_SUCCEEDED(GetFeatureStatusImpl(features[i], &status,
                                           suggestedVersion,
                                           aDriverInfo))) {
       switch (status) {
         default:
         case nsIGfxInfo::FEATURE_NO_INFO:
           RemovePrefForFeature(features[i]);
           break;
         case nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION:
           if (!suggestedVersion.IsEmpty()) {
             SetPrefValueForDriverVersion(suggestedVersion);
           } else {
             RemovePrefForDriverVersion();
           }
           // FALLTHROUGH
         case nsIGfxInfo::FEATURE_BLOCKED_DEVICE:
         case nsIGfxInfo::FEATURE_DISCOURAGED:
         case nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION:
           SetPrefValueForFeature(features[i], status);
           break;
       }
     }
     ++i;
   }
 }
 NS_IMETHODIMP_(void)
 GfxInfoBase::LogFailure(const nsACString &failure)
 {
   MutexAutoLock lock(mMutex);
   /* We only keep the first 9 failures */
   if (mFailureCount < ArrayLength(mFailures)) {
     mFailures[mFailureCount++] = failure;
     /* record it in the crash notes too */
     #if defined(MOZ_CRASHREPORTER)
       CrashReporter::AppendAppNotesToCrashReport(failure);
     #endif
   }
 }
 /* void getFailures ([optional] out unsigned long failureCount, [array, size_is (failureCount), retval] out string failures); */
 /* XPConnect method of returning arrays is very ugly. Would not recommend. Fallable nsMemory::Alloc makes things worse */
 NS_IMETHODIMP GfxInfoBase::GetFailures(uint32_t *failureCount, char ***failures)
 {
   NS_ENSURE_ARG_POINTER(failureCount);
   NS_ENSURE_ARG_POINTER(failures);
   *failures = nullptr;
   *failureCount = mFailureCount;
   if (*failureCount != 0) {
     *failures = (char**)nsMemory::Alloc(*failureCount * sizeof(char*));
     if (!failures)
       return NS_ERROR_OUT_OF_MEMORY;
     /* copy over the failure messages into the array we just allocated */
     for (uint32_t i = 0; i < *failureCount; i++) {
       nsCString& flattenedFailureMessage(mFailures[i]);
       (*failures)[i] = (char*)nsMemory::Clone(flattenedFailureMessage.get(), flattenedFailureMessage.Length() + 1);
       if (!(*failures)[i]) {
         /* <sarcasm> I'm too afraid to use an inline function... </sarcasm> */
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, (*failures));
         return NS_ERROR_OUT_OF_MEMORY;
       }
     }
   }
   return NS_OK;
 }
 nsTArray<GfxInfoCollectorBase*> *sCollectors;
 static void
 InitCollectors()
 {
   if (!sCollectors)
     sCollectors = new nsTArray<GfxInfoCollectorBase*>;
 }
 nsresult GfxInfoBase::GetInfo(JSContext* aCx, JS::MutableHandle<JS::Value> aResult)
 {
   InitCollectors();
   InfoObject obj(aCx);
   for (uint32_t i = 0; i < sCollectors->Length(); i++) {
     (*sCollectors)[i]->GetInfo(obj);
   }
   // Some example property definitions
   // obj.DefineProperty("wordCacheSize", gfxTextRunWordCache::Count());
   // obj.DefineProperty("renderer", mRendererIDsString);
   // obj.DefineProperty("five", 5);
   if (!obj.mOk) {
     return NS_ERROR_FAILURE;
   }
   aResult.setObject(*obj.mObj);
   return NS_OK;
 }
 void
 GfxInfoBase::AddCollector(GfxInfoCollectorBase* collector)
 {
   InitCollectors();
   sCollectors->AppendElement(collector);
 }
 void
 GfxInfoBase::RemoveCollector(GfxInfoCollectorBase* collector)
 {
   InitCollectors();
   for (uint32_t i = 0; i < sCollectors->Length(); i++) {
     if ((*sCollectors)[i] == collector) {
       sCollectors->RemoveElementAt(i);
       break;
     }
   }
   if (sCollectors->IsEmpty()) {
     delete sCollectors;
     sCollectors = nullptr;
   }
 }
 GfxInfoCollectorBase::GfxInfoCollectorBase()
 {
   GfxInfoBase::AddCollector(this);
 }
 GfxInfoCollectorBase::~GfxInfoCollectorBase()
 {
   GfxInfoBase::RemoveCollector(this);
 }

The Tor Browser / annotate

widget/xpwidgets/GfxInfoBase.cpp@6474c204b198 (annotated)

widget/xpwidgets/GfxInfoBase.cpp