port blacklist from mozilla code to LibreOffice, part2

Change-Id: Ia5810aa5f9e1e169b5f0217f6f176a253dc1439d

2 files changed, 411 insertions, 1 deletions

diff --git a/vcl/inc/opengl/win/WinDeviceInfo.hxx b/vcl/inc/opengl/win/WinDeviceInfo.hxx
index 140662e9f840..524198bd5bca 100644
--- a/vcl/inc/opengl/win/WinDeviceInfo.hxx
+++ b/vcl/inc/opengl/win/WinDeviceInfo.hxx
@@ -71,6 +71,67 @@ enum DeviceVendor {
     DeviceVendorMax
 };
 
+struct DriverInfo
+{
+    typedef std::vector<OUString> DeviceFamilyVector;
+
+    // If |ownDevices| is true, you are transferring ownership of the devices
+    // array, and it will be deleted when this GfxDriverInfo is destroyed.
+
+    DriverInfo(OperatingSystem os, const OUString& vendor, DeviceFamilyVector* devices,
+            VersionComparisonOp op,
+            uint64_t driverVersion, const char *suggestedVersion = nullptr,
+            bool ownDevices = false);
+
+    DriverInfo();
+    DriverInfo(const DriverInfo&);
+    ~DriverInfo();
+
+    OperatingSystem meOperatingSystem;
+    uint32_t mnOperatingSystemVersion;
+
+    OUString maAdapterVendor;
+
+    static DeviceFamilyVector* const allDevices;
+    DeviceFamilyVector* mpDevices;
+
+    // Whether the mDevices array should be deleted when this structure is
+    // deallocated. False by default.
+    bool mbDeleteDevices;
+
+    VersionComparisonOp meComparisonOp;
+
+    /* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */
+    uint64_t mnDriverVersion;
+    uint64_t mnDriverVersionMax;
+    static uint64_t allDriverVersions;
+
+    static const DeviceFamilyVector* GetDeviceFamily(DeviceFamily id);
+    static DeviceFamilyVector* mpDeviceFamilies[DeviceFamilyMax];
+
+    OUString maModel, maHardware, maProduct, maManufacturer;
+};
+
+#define GFX_DRIVER_VERSION(a,b,c,d) \
+    ((uint64_t(a)<<48) | (uint64_t(b)<<32) | (uint64_t(c)<<16) | uint64_t(d))
+
+inline uint64_t V(uint32_t a, uint32_t b, uint32_t c, uint32_t d)
+{
+    // We make sure every driver number is padded by 0s, this will allow us the
+    // easiest 'compare as if decimals' approach. See ParseDriverVersion for a
+    // more extensive explanation of this approach.
+    while (b > 0 && b < 1000) {
+        b *= 10;
+    }
+    while (c > 0 && c < 1000) {
+        c *= 10;
+    }
+    while (d > 0 && d < 1000) {
+        d *= 10;
+    }
+    return GFX_DRIVER_VERSION(a, b, c, d);
+}
+
 }
 
 class WinOpenGLDeviceInfo : public OpenGLDeviceInfo
@@ -105,12 +166,15 @@ private:
     bool mbRDP;
 
     void GetData();
-    OUString GetDeviceVendor(wgl::DeviceVendor eVendor);
+    void FillBlacklist();
 
     static OUString* mpDeviceVendors[wgl::DeviceVendorMax];
+    static std::vector<wgl::DriverInfo> maDriverInfo;
 
 public:
     WinOpenGLDeviceInfo();
+
+    static OUString GetDeviceVendor(wgl::DeviceVendor eVendor);
     virtual ~WinOpenGLDeviceInfo();
 
     virtual bool isDeviceBlocked();
diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx
index b1ddf2f981cf..e319c43537aa 100644
--- a/vcl/opengl/win/WinDeviceInfo.cxx
+++ b/vcl/opengl/win/WinDeviceInfo.cxx
@@ -14,6 +14,22 @@
 #include <cstdint>
 
 OUString* WinOpenGLDeviceInfo::mpDeviceVendors[wgl::DeviceVendorMax];
+std::vector<wgl::DriverInfo> WinOpenGLDeviceInfo::maDriverInfo;
+
+#define APPEND_TO_DRIVER_BLOCKLIST(os, vendor, devices, driverComparator, driverVersion, suggestedVersion) \
+    maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion, suggestedVersion))
+#define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, devices, driverComparator, driverVersion) \
+    maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion))
+
+#define APPEND_TO_DRIVER_BLOCKLIST_RANGE(os, vendor, devices, driverComparator, driverVersion, driverVersionMax, suggestedVersion) \
+    do { \
+        assert(driverComparator == wgl::DRIVER_BETWEEN_EXCLUSIVE || \
+                driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE || \
+                driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE_START); \
+        wgl::DriverInfo info(os, vendor, devices, driverComparator, driverVersion, suggestedVersion); \
+        info.mnDriverVersionMax = driverVersionMax; \
+        maDriverInfo.push_back(info); \
+    } while (false)
 
 namespace {
 
@@ -318,6 +334,211 @@ template<typename T> void appendIntegerWithPadding(OUString& rString, T value, s
 #define DEVICE_KEY_PREFIX L"\\Registry\\Machine\\"
 }
 
+namespace wgl {
+
+uint64_t DriverInfo::allDriverVersions = ~(uint64_t(0));
+DriverInfo::DeviceFamilyVector* const DriverInfo::allDevices = nullptr;
+
+DriverInfo::DeviceFamilyVector* DriverInfo::mpDeviceFamilies[DeviceFamilyMax];
+
+DriverInfo::DriverInfo()
+    : meOperatingSystem(wgl::DRIVER_OS_UNKNOWN),
+    mnOperatingSystemVersion(0),
+    maAdapterVendor(WinOpenGLDeviceInfo::GetDeviceVendor(VendorAll)),
+    mpDevices(allDevices),
+    mbDeleteDevices(false),
+    meComparisonOp(DRIVER_COMPARISON_IGNORED),
+    mnDriverVersion(0),
+    mnDriverVersionMax(0)
+{}
+
+DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor,
+        DeviceFamilyVector* devices,
+        VersionComparisonOp op,
+        uint64_t driverVersion,
+        const char *suggestedVersion /* = nullptr */,
+        bool ownDevices /* = false */)
+    : meOperatingSystem(os),
+    mnOperatingSystemVersion(0),
+    maAdapterVendor(vendor),
+    mpDevices(devices),
+    mbDeleteDevices(ownDevices),
+    meComparisonOp(op),
+    mnDriverVersion(driverVersion),
+    mnDriverVersionMax(0)
+{}
+
+DriverInfo::DriverInfo(const DriverInfo& aOrig)
+    : meOperatingSystem(aOrig.meOperatingSystem),
+    mnOperatingSystemVersion(aOrig.mnOperatingSystemVersion),
+    maAdapterVendor(aOrig.maAdapterVendor),
+    meComparisonOp(aOrig.meComparisonOp),
+    mnDriverVersion(aOrig.mnDriverVersion),
+    mnDriverVersionMax(aOrig.mnDriverVersionMax)
+{
+    //If we're managing the lifetime of the device family, we have to make a
+    // copy of the original's device family.
+    if (aOrig.mbDeleteDevices && aOrig.mpDevices) {
+        mpDevices = new DeviceFamilyVector;
+        *mpDevices = *aOrig.mpDevices;
+    } else {
+        mpDevices = aOrig.mpDevices;
+    }
+
+    mbDeleteDevices = aOrig.mbDeleteDevices;
+}
+
+DriverInfo::~DriverInfo()
+{
+    if (mbDeleteDevices)
+        delete mpDevices;
+}
+
+// Macros for appending a device to the DeviceFamily.
+#define APPEND_DEVICE(device) APPEND_DEVICE2(#device)
+#define APPEND_DEVICE2(device) deviceFamily->push_back(OUString("#device"))
+
+const DriverInfo::DeviceFamilyVector* DriverInfo::GetDeviceFamily(DeviceFamily id)
+{
+    // The code here is too sensitive to fall through to the default case if the
+    // code is invalid.
+    assert(id >= 0 && id < DeviceFamilyMax);
+
+    // If it already exists, we must have processed it once, so return it now.
+    if (mpDeviceFamilies[id])
+        return mpDeviceFamilies[id];
+
+    mpDeviceFamilies[id] = new wgl::DriverInfo::DeviceFamilyVector;
+    wgl::DriverInfo::DeviceFamilyVector* deviceFamily = mpDeviceFamilies[id];
+
+    switch (id) {
+        case IntelGMA500:
+            APPEND_DEVICE(0x8108); /* IntelGMA500_1 */
+            APPEND_DEVICE(0x8109); /* IntelGMA500_2 */
+            break;
+        case IntelGMA900:
+            APPEND_DEVICE(0x2582); /* IntelGMA900_1 */
+            APPEND_DEVICE(0x2782); /* IntelGMA900_2 */
+            APPEND_DEVICE(0x2592); /* IntelGMA900_3 */
+            APPEND_DEVICE(0x2792); /* IntelGMA900_4 */
+            break;
+        case IntelGMA950:
+            APPEND_DEVICE(0x2772); /* Intel945G_1 */
+            APPEND_DEVICE(0x2776); /* Intel945G_2 */
+            APPEND_DEVICE(0x27a2); /* Intel945_1 */
+            APPEND_DEVICE(0x27a6); /* Intel945_2 */
+            APPEND_DEVICE(0x27ae); /* Intel945_3 */
+            break;
+        case IntelGMA3150:
+            APPEND_DEVICE(0xa001); /* IntelGMA3150_Nettop_1 */
+            APPEND_DEVICE(0xa002); /* IntelGMA3150_Nettop_2 */
+            APPEND_DEVICE(0xa011); /* IntelGMA3150_Netbook_1 */
+            APPEND_DEVICE(0xa012); /* IntelGMA3150_Netbook_2 */
+            break;
+        case IntelGMAX3000:
+            APPEND_DEVICE(0x2972); /* Intel946GZ_1 */
+            APPEND_DEVICE(0x2973); /* Intel946GZ_2 */
+            APPEND_DEVICE(0x2982); /* IntelG35_1 */
+            APPEND_DEVICE(0x2983); /* IntelG35_2 */
+            APPEND_DEVICE(0x2992); /* IntelQ965_1 */
+            APPEND_DEVICE(0x2993); /* IntelQ965_2 */
+            APPEND_DEVICE(0x29a2); /* IntelG965_1 */
+            APPEND_DEVICE(0x29a3); /* IntelG965_2 */
+            APPEND_DEVICE(0x29b2); /* IntelQ35_1 */
+            APPEND_DEVICE(0x29b3); /* IntelQ35_2 */
+            APPEND_DEVICE(0x29c2); /* IntelG33_1 */
+            APPEND_DEVICE(0x29c3); /* IntelG33_2 */
+            APPEND_DEVICE(0x29d2); /* IntelQ33_1 */
+            APPEND_DEVICE(0x29d3); /* IntelQ33_2 */
+            APPEND_DEVICE(0x2a02); /* IntelGL960_1 */
+            APPEND_DEVICE(0x2a03); /* IntelGL960_2 */
+            APPEND_DEVICE(0x2a12); /* IntelGM965_1 */
+            APPEND_DEVICE(0x2a13); /* IntelGM965_2 */
+            break;
+        case IntelGMAX4500HD:
+            APPEND_DEVICE(0x2a42); /* IntelGMA4500MHD_1 */
+            APPEND_DEVICE(0x2a43); /* IntelGMA4500MHD_2 */
+            APPEND_DEVICE(0x2e42); /* IntelB43_1 */
+            APPEND_DEVICE(0x2e43); /* IntelB43_2 */
+            APPEND_DEVICE(0x2e92); /* IntelB43_3 */
+            APPEND_DEVICE(0x2e93); /* IntelB43_4 */
+            APPEND_DEVICE(0x2e32); /* IntelG41_1 */
+            APPEND_DEVICE(0x2e33); /* IntelG41_2 */
+            APPEND_DEVICE(0x2e22); /* IntelG45_1 */
+            APPEND_DEVICE(0x2e23); /* IntelG45_2 */
+            APPEND_DEVICE(0x2e12); /* IntelQ45_1 */
+            APPEND_DEVICE(0x2e13); /* IntelQ45_2 */
+            APPEND_DEVICE(0x0042); /* IntelHDGraphics */
+            APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */
+            APPEND_DEVICE(0x0102); /* IntelSandyBridge_1 */
+            APPEND_DEVICE(0x0106); /* IntelSandyBridge_2 */
+            APPEND_DEVICE(0x0112); /* IntelSandyBridge_3 */
+            APPEND_DEVICE(0x0116); /* IntelSandyBridge_4 */
+            APPEND_DEVICE(0x0122); /* IntelSandyBridge_5 */
+            APPEND_DEVICE(0x0126); /* IntelSandyBridge_6 */
+            APPEND_DEVICE(0x010a); /* IntelSandyBridge_7 */
+            APPEND_DEVICE(0x0080); /* IntelIvyBridge */
+            break;
+        case IntelHD3000:
+            APPEND_DEVICE(0x0126);
+            break;
+        case IntelMobileHDGraphics:
+            APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */
+            break;
+        case NvidiaBlockD3D9Layers:
+            // Glitches whilst scrolling (see bugs 612007, 644787, 645872)
+            APPEND_DEVICE(0x00f3); /* NV43 [GeForce 6200 (TM)] */
+            APPEND_DEVICE(0x0146); /* NV43 [Geforce Go 6600TE/6200TE (TM)] */
+            APPEND_DEVICE(0x014f); /* NV43 [GeForce 6200 (TM)] */
+            APPEND_DEVICE(0x0161); /* NV44 [GeForce 6200 TurboCache (TM)] */
+            APPEND_DEVICE(0x0162); /* NV44 [GeForce 6200SE TurboCache (TM)] */
+            APPEND_DEVICE(0x0163); /* NV44 [GeForce 6200 LE (TM)] */
+            APPEND_DEVICE(0x0164); /* NV44 [GeForce Go 6200 (TM)] */
+            APPEND_DEVICE(0x0167); /* NV43 [GeForce Go 6200/6400 (TM)] */
+            APPEND_DEVICE(0x0168); /* NV43 [GeForce Go 6200/6400 (TM)] */
+            APPEND_DEVICE(0x0169); /* NV44 [GeForce 6250 (TM)] */
+            APPEND_DEVICE(0x0222); /* NV44 [GeForce 6200 A-LE (TM)] */
+            APPEND_DEVICE(0x0240); /* C51PV [GeForce 6150 (TM)] */
+            APPEND_DEVICE(0x0241); /* C51 [GeForce 6150 LE (TM)] */
+            APPEND_DEVICE(0x0244); /* C51 [Geforce Go 6150 (TM)] */
+            APPEND_DEVICE(0x0245); /* C51 [Quadro NVS 210S/GeForce 6150LE (TM)] */
+            APPEND_DEVICE(0x0247); /* C51 [GeForce Go 6100 (TM)] */
+            APPEND_DEVICE(0x03d0); /* C61 [GeForce 6150SE nForce 430 (TM)] */
+            APPEND_DEVICE(0x03d1); /* C61 [GeForce 6100 nForce 405 (TM)] */
+            APPEND_DEVICE(0x03d2); /* C61 [GeForce 6100 nForce 400 (TM)] */
+            APPEND_DEVICE(0x03d5); /* C61 [GeForce 6100 nForce 420 (TM)] */
+            break;
+        case RadeonX1000:
+            // This list is from the ATIRadeonX1000.kext Info.plist
+            APPEND_DEVICE(0x7187);
+            APPEND_DEVICE(0x7210);
+            APPEND_DEVICE(0x71de);
+            APPEND_DEVICE(0x7146);
+            APPEND_DEVICE(0x7142);
+            APPEND_DEVICE(0x7109);
+            APPEND_DEVICE(0x71c5);
+            APPEND_DEVICE(0x71c0);
+            APPEND_DEVICE(0x7240);
+            APPEND_DEVICE(0x7249);
+            APPEND_DEVICE(0x7291);
+            break;
+        case Geforce7300GT:
+            APPEND_DEVICE(0x0393);
+            break;
+        case Nvidia310M:
+            APPEND_DEVICE(0x0A70);
+            break;
+            // This should never happen, but we get a warning if we don't handle this.
+        case DeviceFamilyMax:
+            SAL_WARN("vcl.opengl", "Invalid DeviceFamily id");
+            break;
+    }
+
+    return deviceFamily;
+}
+
+}
+
 WinOpenGLDeviceInfo::WinOpenGLDeviceInfo():
     mbHasDualGPU(false),
     mbHasDriverVersionMismatch(false),
@@ -629,5 +850,130 @@ OUString WinOpenGLDeviceInfo::GetDeviceVendor(wgl::DeviceVendor id)
     return *mpDeviceVendors[id];
 }
 
+void WinOpenGLDeviceInfo::FillBlacklist()
+{
+    /*
+     * It should be noted here that more specialized rules on certain features
+     * should be inserted -before- more generalized restriction. As the first
+     * match for feature/OS/device found in the list will be used for the final
+     * blacklisting call.
+     */
+
+    /*
+     * NVIDIA entries
+     */
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_XP,
+            GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::V(6,14,11,8265), "182.65" );
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_VISTA,
+            GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::V(8,17,11,8265), "182.65" );
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_7,
+            GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::V(8,17,11,8265), "182.65" );
+
+    /*
+     * AMD/ATI entries
+     */
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::V(8,62,0,0), "9.6" );
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::V(8,62,0,0), "9.6" );
+
+    /*
+     * Bug 783517 - crashes in AMD driver on Windows 8
+     */
+    APPEND_TO_DRIVER_BLOCKLIST_RANGE( wgl::DRIVER_OS_WINDOWS_8,
+            GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_BETWEEN_INCLUSIVE_START, wgl::V(8,982,0,0), wgl::V(8,983,0,0), "!= 8.982.*.*" );
+    APPEND_TO_DRIVER_BLOCKLIST_RANGE( wgl::DRIVER_OS_WINDOWS_8,
+            GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_BETWEEN_INCLUSIVE_START, wgl::V(8,982,0,0), wgl::V(8,983,0,0), "!= 8.982.*.*" );
+
+    /* OpenGL on any ATI/AMD hardware is discouraged
+     * See:
+     *  bug 619773 - WebGL: Crash with blue screen : "NMI: Parity Check / Memory Parity Error"
+     *  bugs 584403, 584404, 620924 - crashes in atioglxx
+     *  + many complaints about incorrect rendering
+     */
+    APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions );
+    APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions );
+    APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions );
+    APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions );
+
+    /*
+     * Intel entries
+     */
+
+    /* The driver versions used here come from bug 594877. They might not
+     * be particularly relevant anymore.
+     */
+#define IMPLEMENT_INTEL_DRIVER_BLOCKLIST(winVer, devFamily, driverVer)                                                      \
+    APPEND_TO_DRIVER_BLOCKLIST2( winVer,                                                                                      \
+            GetDeviceVendor(wgl::VendorIntel), (wgl::DriverInfo::DeviceFamilyVector*) wgl::DriverInfo::GetDeviceFamily(devFamily), \
+            wgl::DRIVER_LESS_THAN, driverVer )
+
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA500,   wgl::V(3,0,20,3200));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA900,   wgl::V(6,14,10,4764));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA950,   wgl::V(6,14,10,4926));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA3150,  wgl::V(6,14,10,5134));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMAX3000, wgl::V(6,14,10,5218));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMAX4500HD, wgl::V(6,14,10,4969));
+
+    // StrechRect seems to suffer from precision issues which leads to artifacting
+    // during content drawing starting with at least version 6.14.10.5082
+    // and going until 6.14.10.5218. See bug 919454 and bug 949275 for more info.
+    APPEND_TO_DRIVER_BLOCKLIST_RANGE(wgl::DRIVER_OS_WINDOWS_XP,
+            GetDeviceVendor(wgl::VendorIntel),
+            const_cast<wgl::DriverInfo::DeviceFamilyVector*>(wgl::DriverInfo::GetDeviceFamily(wgl::IntelGMAX4500HD)),
+            wgl::DRIVER_BETWEEN_EXCLUSIVE, wgl::V(6,14,10,5076), wgl::V(6,14,10,5218), "6.14.10.5218");
+
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA500,   wgl::V(3,0,20,3200));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA900,   wgl::DriverInfo::allDriverVersions);
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA950,   wgl::V(7,14,10,1504));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA3150,  wgl::V(7,14,10,1910));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMAX3000, wgl::V(7,15,10,1666));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMAX4500HD, wgl::V(7,15,10,1666));
+
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA500,   wgl::V(5,0,0,2026));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA900,   wgl::DriverInfo::allDriverVersions);
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA950,   wgl::V(8,15,10,1930));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA3150,  wgl::V(8,14,10,1972));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMAX3000, wgl::V(7,15,10,1666));
+    IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMAX4500HD, wgl::V(7,15,10,1666));
+
+    /* OpenGL on any Intel hardware is discouraged */
+    APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorIntel), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions );
+    APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorIntel), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions );
+
+    /**
+     * Disable acceleration on Intel HD 3000 for graphics drivers <= 8.15.10.2321.
+     * See bug 1018278 and bug 1060736.
+     */
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorIntel), (wgl::DriverInfo::DeviceFamilyVector*) wgl::DriverInfo::GetDeviceFamily(wgl::IntelHD3000),
+            wgl::DRIVER_LESS_THAN_OR_EQUAL, wgl::V(8,15,10,2321), "8.15.10.2342" );
+
+    /* Microsoft RemoteFX; blocked less than 6.2.0.0 */
+    APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL,
+            GetDeviceVendor(wgl::VendorMicrosoft), wgl::DriverInfo::allDevices,
+            wgl::DRIVER_LESS_THAN, wgl::V(6,2,0,0), "< 6.2.0.0" );
+
+}
+
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */