mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out 8 changesets (bug 1268638) for build bustage CLOSED TREE 

Backed out changeset 1a2db6efc575 (bug 1268638)
Backed out changeset ad38e0439b62 (bug 1268638)
Backed out changeset 0078605c6974 (bug 1268638)
Backed out changeset 8ed7ed6c57db (bug 1268638)
Backed out changeset 69116551e4b9 (bug 1268638)
Backed out changeset 002f87a61edf (bug 1268638)
Backed out changeset 8b0db9b0f87c (bug 1268638)
Backed out changeset 5d1285d0c221 (bug 1268638)
This commit is contained in:
Wes Kocher 2016-06-21 14:53:22 -07:00
Родитель bb57c9c62d
Коммит 8e4ef7176d
9 изменённых файлов: 117 добавлений и 188 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

9
dom/canvas/WebGL2Context.cpp
Просмотреть файл

@ -97,7 +97,7 @@ static const gl::GLFeature kRequiredFeatures[] = {
};
bool
WebGLContext::InitWebGL2(FailureReason* const out_failReason)
WebGLContext::InitWebGL2(nsACString* const out_failReason, nsACString* const out_failureId)
{
MOZ_ASSERT(IsWebGL2(), "WebGLContext is not a WebGL 2 context!");
@ -107,8 +107,8 @@ WebGLContext::InitWebGL2(FailureReason* const out_failReason)
{
// On desktop, we fake occlusion_query_boolean with occlusion_query if
// necessary. (See WebGL2ContextQueries.cpp)
*out_failReason = FailureReason("FEATURE_FAILURE_WEBGL2_OCCL",
"WebGL 2 requires occlusion query support.");
*out_failureId = "FEATURE_FAILURE_WEBGL2_OCCL";
out_failReason->AssignASCII("WebGL 2 requires occlusion query support.");
return false;
}
@ -136,10 +136,11 @@ WebGLContext::InitWebGL2(FailureReason* const out_failReason)
exts.Append(gl::GLContext::GetFeatureName(*itr));
}
*out_failureId = "FEATURE_FAILURE_WEBGL2_FEATURE";
const nsPrintfCString reason("WebGL 2 requires support for the following"
" features: %s",
exts.BeginReading());
*out_failReason = FailureReason("FEATURE_FAILURE_WEBGL2_OCCL", reason);
out_failReason->Assign(reason);
return false;
}

195
dom/canvas/WebGLContext.cpp
Просмотреть файл

@ -76,10 +76,6 @@
#include "nsCocoaFeatures.h"
#endif
#ifdef XP_WIN
#include "WGLLibrary.h"
#endif
// Generated
#include "mozilla/dom/WebGLRenderingContextBinding.h"
@ -439,15 +435,12 @@ WebGLContext::GetHeight() const
*/
static bool
IsFeatureInBlacklist(const nsCOMPtr<nsIGfxInfo>& gfxInfo, int32_t feature,
nsCString* const out_blacklistId)
IsFeatureInBlacklist(const nsCOMPtr<nsIGfxInfo>& gfxInfo, int32_t feature, nsACString* const out_failureId)
{
int32_t status;
if (!NS_SUCCEEDED(gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo, feature,
*out_blacklistId, &status)))
{
*out_failureId, &status)))
return false;
}
return status != nsIGfxInfo::FEATURE_STATUS_OK;
}
@ -570,15 +563,15 @@ BaseCaps(const WebGLContextOptions& options, WebGLContext* webgl)
// Done with baseCaps construction.
if (!gfxPrefs::WebGLForceMSAA()) {
const nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
nsCString blocklistId;
if (IsFeatureInBlacklist(gfxInfo, nsIGfxInfo::FEATURE_WEBGL_MSAA, &blocklistId)) {
webgl->GenerateWarning("Disallowing antialiased backbuffers due"
" to blacklisting.");
baseCaps.antialias = false;
}
bool forceAllowAA = gfxPrefs::WebGLForceMSAA();
nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
nsCString discardFailureId;
if (!forceAllowAA &&
IsFeatureInBlacklist(gfxInfo, nsIGfxInfo::FEATURE_WEBGL_MSAA, &discardFailureId))
{
webgl->GenerateWarning("Disallowing antialiased backbuffers due"
" to blacklisting.");
baseCaps.antialias = false;
}
return baseCaps;
@ -588,8 +581,8 @@ BaseCaps(const WebGLContextOptions& options, WebGLContext* webgl)
static already_AddRefed<gl::GLContext>
CreateGLWithEGL(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
WebGLContext* webgl,
std::vector<WebGLContext::FailureReason>* const out_failReasons)
WebGLContext* webgl, nsACString* const out_failReason,
nsACString* const out_failureId)
{
const gfx::IntSize dummySize(16, 16);
RefPtr<GLContext> gl = gl::GLContextProviderEGL::CreateOffscreen(dummySize, caps,
@ -599,10 +592,13 @@ CreateGLWithEGL(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
}
if (!gl) {
out_failReasons->push_back(WebGLContext::FailureReason(
"FEATURE_FAILURE_WEBGL_EGL_INIT",
"Error during EGL OpenGL init."
));
if (out_failReason->Length()) {
out_failReason->AppendLiteral("\n");
}
out_failReason->AppendLiteral("Error during EGL OpenGL init.");
if (out_failureId->IsEmpty()) {
*out_failureId = "FEATURE_FAILURE_WEBGL_EGL_INIT";
}
return nullptr;
}
@ -611,8 +607,8 @@ CreateGLWithEGL(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
static already_AddRefed<GLContext>
CreateGLWithANGLE(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
WebGLContext* webgl,
std::vector<WebGLContext::FailureReason>* const out_failReasons)
WebGLContext* webgl, nsACString* const out_failReason,
nsACString* const out_failureId)
{
const gfx::IntSize dummySize(16, 16);
RefPtr<GLContext> gl = gl::GLContextProviderEGL::CreateOffscreen(dummySize, caps,
@ -622,10 +618,13 @@ CreateGLWithANGLE(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
}
if (!gl) {
out_failReasons->push_back(WebGLContext::FailureReason(
"FEATURE_FAILURE_WEBGL_ANGLE_INIT",
"Error during ANGLE OpenGL init."
));
if (out_failReason->Length()) {
out_failReason->AppendLiteral("\n");
}
out_failReason->AppendLiteral("Error during ANGLE OpenGL init.");
if (out_failureId->IsEmpty()) {
*out_failureId = "FEATURE_FAILURE_WEBGL_ANGLE_INIT";
}
return nullptr;
}
@ -634,9 +633,22 @@ CreateGLWithANGLE(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
static already_AddRefed<gl::GLContext>
CreateGLWithDefault(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
WebGLContext* webgl,
std::vector<WebGLContext::FailureReason>* const out_failReasons)
WebGLContext* webgl, nsACString* const out_failReason,
nsACString* const out_failureId)
{
nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
if (!(flags & CreateContextFlags::FORCE_ENABLE_HARDWARE) &&
IsFeatureInBlacklist(gfxInfo, nsIGfxInfo::FEATURE_WEBGL_OPENGL, out_failureId))
{
if (out_failReason->Length()) {
out_failReason->AppendASCII("\n");
}
out_failReason->AppendASCII("Refused to create native OpenGL context because of"
" blacklisting.");
return nullptr;
}
const gfx::IntSize dummySize(16, 16);
RefPtr<GLContext> gl = gl::GLContextProvider::CreateOffscreen(dummySize, caps,
flags, out_failureId);
@ -646,10 +658,13 @@ CreateGLWithDefault(const gl::SurfaceCaps& caps, gl::CreateContextFlags flags,
}
if (!gl) {
out_failReasons->push_back(WebGLContext::FailureReason(
"FEATURE_FAILURE_WEBGL_DEFAULT_INIT",
"Error during native OpenGL init."
));
if (out_failReason->Length()) {
out_failReason->AppendASCII("\n");
}
out_failReason->AppendASCII("Error during native OpenGL init.");
if (out_failureId->IsEmpty()) {
*out_failureId = "FEATURE_FAILURE_WEBGL_DEFAULT_INIT";
}
return nullptr;
}
@ -662,7 +677,8 @@ bool
WebGLContext::CreateAndInitGLWith(FnCreateGL_T fnCreateGL,
const gl::SurfaceCaps& baseCaps,
gl::CreateContextFlags flags,
std::vector<FailureReason>* const out_failReasons)
nsACString* const out_failReason,
nsACString* const out_failureId)
{
std::queue<gl::SurfaceCaps> fallbackCaps;
PopulateCapFallbackQueue(baseCaps, &fallbackCaps);
@ -670,8 +686,9 @@ WebGLContext::CreateAndInitGLWith(FnCreateGL_T fnCreateGL,
MOZ_RELEASE_ASSERT(!gl, "GFX: Already have a context.");
gl = nullptr;
while (!fallbackCaps.empty()) {
const gl::SurfaceCaps& caps = fallbackCaps.front();
gl = fnCreateGL(caps, flags, this, out_failReasons);
gl::SurfaceCaps& caps = fallbackCaps.front();
gl = fnCreateGL(caps, flags, this, out_failReason, out_failureId);
if (gl)
break;
@ -680,11 +697,9 @@ WebGLContext::CreateAndInitGLWith(FnCreateGL_T fnCreateGL,
if (!gl)
return false;
FailureReason reason;
if (!InitAndValidateGL(&reason)) {
if (!InitAndValidateGL(out_failReason, out_failureId)) {
// The fail reason here should be specific enough for now.
gl = nullptr;
out_failReasons->push_back(reason);
return false;
}
@ -692,31 +707,16 @@ WebGLContext::CreateAndInitGLWith(FnCreateGL_T fnCreateGL,
}
bool
WebGLContext::CreateAndInitGL(bool forceEnabled,
std::vector<FailureReason>* const out_failReasons)
WebGLContext::CreateAndInitGL(bool forceEnabled, nsACString* const out_failReason, nsACString* const out_failureId)
{
bool disableNativeGL = true;
if (forceEnabled) {
disableNativeGL = false;
} else if (IsWebGL2()) {
const nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
const auto feature = nsIGfxInfo::FEATURE_WEBGL_OPENGL;
const bool useEGL = PR_GetEnv("MOZ_WEBGL_PREFER_EGL");
FailureReason reason;
if (IsFeatureInBlacklist(gfxInfo, feature, &reason.key)) {
reason.info = "Refused to create native OpenGL context because of blacklist"
" entry: ";
reason.info.Append(reason.key);
out_failReasons->push_back(reason);
GenerateWarning(reason.info.BeginReading());
} else {
disableNativeGL = false;
}
}
//////
bool useANGLE = false;
#ifdef XP_WIN
const bool disableANGLE = (gfxPrefs::WebGLDisableANGLE() ||
PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL"));
useANGLE = !disableANGLE;
#endif
gl::CreateContextFlags flags = gl::CreateContextFlags::NO_VALIDATION;
@ -726,43 +726,13 @@ WebGLContext::CreateAndInitGL(bool forceEnabled,
const gl::SurfaceCaps baseCaps = BaseCaps(mOptions, this);
//////
if (!disableNativeGL) {
const bool useEGL = PR_GetEnv("MOZ_WEBGL_FORCE_EGL");
if (useEGL)
return CreateAndInitGLWith(CreateGLWithEGL, baseCaps, flags, out_failReasons);
bool tryNativeGL = true;
#ifdef XP_WIN
if (gfxPrefs::WebGLDisableWGL()) {
tryNativeGL = false;
}
#endif
if (tryNativeGL) {
if (CreateAndInitGLWith(CreateGLWithNative, baseCaps, flags, out_failReasons))
return true;
}
}
//////
bool useANGLE = false;
#ifdef XP_WIN
const bool disableANGLE = (gfxPrefs::WebGLDisableANGLE() ||
PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL"));
useANGLE = !disableANGLE;
#endif
if (useEGL)
return CreateAndInitGLWith(CreateGLWithEGL, baseCaps, flags, out_failReason, out_failureId);
if (useANGLE)
return CreateAndInitGLWith(CreateGLWithANGLE, baseCaps, flags, out_failReasons);
return CreateAndInitGLWith(CreateGLWithANGLE, baseCaps, flags, out_failReason, out_failureId);
//////
out_failReasons->push_back(FailureReason("FEATURE_FAILURE_WEBGL_EXHAUSTED_DRIVERS",
"Exhausted GL driver options."));
return false;
return CreateAndInitGLWith(CreateGLWithDefault, baseCaps, flags, out_failReason, out_failureId);
}
// Fallback for resizes:
@ -960,15 +930,12 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight)
ScopedGfxFeatureReporter reporter("WebGL", forceEnabled);
MOZ_ASSERT(!gl);
std::vector<FailureReason> failReasons;
if (!CreateAndInitGL(forceEnabled, &failReasons)) {
nsCString text("WebGL creation failed: ");
for (const auto& cur : failReasons) {
Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_FAILURE_ID, cur.key);
text.AppendASCII("\n* ");
text.Append(cur.info);
}
nsCString failReason;
nsCString failureId;
if (!CreateAndInitGL(forceEnabled, &failReason, &failureId)) {
Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_FAILURE_ID, failureId);
const nsPrintfCString text("WebGL creation failed: %s",
failReason.BeginReading());
ThrowEvent_WebGLContextCreationError(text);
return NS_ERROR_FAILURE;
}
@ -977,8 +944,6 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight)
if (mOptions.failIfMajorPerformanceCaveat) {
if (gl->IsWARP()) {
gl = nullptr;
Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_FAILURE_ID,
NS_LITERAL_CSTRING("FEATURE_FAILURE_PERF_WARP"));
const nsLiteralCString text("failIfMajorPerformanceCaveat: Driver is not"
@ -986,16 +951,6 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight)
ThrowEvent_WebGLContextCreationError(text);
return NS_ERROR_FAILURE;
}
if (gl->GetContextType() == gl::GLContextType::WGL &&
!gl::sWGLLib.HasDXInterop2())
{
gl = nullptr;
const nsLiteralCString text("Caveat: WGL without DXGLInterop2.");
ThrowEvent_WebGLContextCreationError(text);
return NS_ERROR_FAILURE;
}
}
if (!ResizeBackbuffer(width, height)) {

28
dom/canvas/WebGLContext.h
Просмотреть файл

@ -1201,41 +1201,27 @@ protected:
public:
virtual bool IsWebGL2() const = 0;
struct FailureReason {
nsCString key; // For reporting.
nsCString info;
FailureReason() { }
template<typename A, typename B>
FailureReason(const A& _key, const B& _info)
: key(nsCString(_key))
, info(nsCString(_info))
{ }
};
protected:
bool InitWebGL2(FailureReason* const out_failReason);
bool CreateAndInitGL(bool forceEnabled,
std::vector<FailureReason>* const out_failReasons);
bool InitWebGL2(nsACString* const out_failReason, nsACString* const out_failureId);
bool CreateAndInitGL(bool forceEnabled, nsACString* const out_failReason, nsACString* const out_failureId);
bool ResizeBackbuffer(uint32_t width, uint32_t height);
typedef already_AddRefed<gl::GLContext> FnCreateGL_T(const gl::SurfaceCaps& caps,
gl::CreateContextFlags flags,
WebGLContext* webgl,
std::vector<FailureReason>* const out_failReasons);
nsACString* const out_failReason,
nsACString* const out_failureId);
bool CreateAndInitGLWith(FnCreateGL_T fnCreateGL, const gl::SurfaceCaps& baseCaps,
gl::CreateContextFlags flags,
std::vector<FailureReason>* const out_failReasons);
nsACString* const out_failReason,
nsACString* const out_failureId);
void ThrowEvent_WebGLContextCreationError(const nsACString& text);
// -------------------------------------------------------------------------
// Validation functions (implemented in WebGLContextValidate.cpp)
bool InitAndValidateGL(FailureReason* const out_failReason);
bool InitAndValidateGL(nsACString* const out_failReason, nsACString* const out_failureId);
bool ValidateBlendEquationEnum(GLenum cap, const char* info);
bool ValidateBlendFuncDstEnum(GLenum mode, const char* info);
bool ValidateBlendFuncSrcEnum(GLenum mode, const char* info);

24
dom/canvas/WebGLContextValidate.cpp
Просмотреть файл

@ -648,7 +648,7 @@ FloorPOT(int32_t x)
}
bool
WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
WebGLContext::InitAndValidateGL(nsACString* const out_failReason, nsACString* const out_failureId)
{
MOZ_RELEASE_ASSERT(gl, "GFX: GL not initialized");
@ -657,17 +657,18 @@ WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
// formats back into the authority.
mFormatUsage = CreateFormatUsage(gl);
if (!mFormatUsage) {
*out_failReason = { "FEATURE_FAILURE_WEBGL_FORMAT",
"Failed to create mFormatUsage." };
*out_failureId = "FEATURE_FAILURE_WEBGL_FORMAT";
out_failReason->AssignLiteral("Failed to create mFormatUsage.");
return false;
}
GLenum error = gl->fGetError();
if (error != LOCAL_GL_NO_ERROR) {
*out_failureId = "FEATURE_FAILURE_WEBGL_GLERR_1";
const nsPrintfCString reason("GL error 0x%x occurred during OpenGL context"
" initialization, before WebGL initialization!",
error);
*out_failReason = { "FEATURE_FAILURE_WEBGL_GLERR_1", reason };
out_failReason->Assign(reason);
return false;
}
@ -756,9 +757,10 @@ WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_ATTRIBS, &mGLMaxVertexAttribs);
if (mGLMaxVertexAttribs < 8) {
*out_failureId = "FEATURE_FAILURE_WEBGL_V_ATRB";
const nsPrintfCString reason("GL_MAX_VERTEX_ATTRIBS: %d is < 8!",
mGLMaxVertexAttribs);
*out_failReason = { "FEATURE_FAILURE_WEBGL_V_ATRB", reason };
out_failReason->Assign(reason);
return false;
}
@ -771,9 +773,10 @@ WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
gl->fGetIntegerv(LOCAL_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGLMaxTextureUnits);
if (mGLMaxTextureUnits < 8) {
*out_failureId = "FEATURE_FAILURE_WEBGL_T_UNIT";
const nsPrintfCString reason("GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: %d is < 8!",
mGLMaxTextureUnits);
*out_failReason = { "FEATURE_FAILURE_WEBGL_T_UNIT", reason };
out_failReason->Assign(reason);
return false;
}
@ -929,8 +932,8 @@ WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
// initialize shader translator
if (!ShInitialize()) {
*out_failReason = { "FEATURE_FAILURE_WEBGL_GLSL",
"GLSL translator initialization failed!" };
*out_failureId = "FEATURE_FAILURE_WEBGL_GLSL";
out_failReason->AssignLiteral("GLSL translator initialization failed!");
return false;
}
@ -944,15 +947,16 @@ WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
// getError call will give the correct result.
error = gl->fGetError();
if (error != LOCAL_GL_NO_ERROR) {
*out_failureId = "FEATURE_FAILURE_WEBGL_GLERR_2";
const nsPrintfCString reason("GL error 0x%x occurred during WebGL context"
" initialization!",
error);
*out_failReason = { "FEATURE_FAILURE_WEBGL_GLERR_2", reason };
out_failReason->Assign(reason);
return false;
}
if (IsWebGL2() &&
!InitWebGL2(out_failReason))
!InitWebGL2(out_failReason, out_failureId))
{
// Todo: Bug 898404: Only allow WebGL2 on GL>=3.0 on desktop GL.
return false;

7
gfx/layers/ipc/ISurfaceAllocator.cpp
Просмотреть файл

@ -7,7 +7,6 @@
#include "ISurfaceAllocator.h"
#include "gfxPrefs.h"
#include "mozilla/layers/ImageBridgeParent.h" // for ImageBridgeParent
#include "mozilla/layers/TextureHost.h" // for TextureHost
@ -288,11 +287,5 @@ FixedSizeSmallShmemSectionAllocator::ShrinkShmemSectionHeap()
}
}
int32_t
ClientIPCAllocator::GetMaxTextureSize() const
{
return gfxPrefs::MaxTextureSize();
}
} // namespace layers
} // namespace mozilla

3
gfx/layers/ipc/ISurfaceAllocator.h
Просмотреть файл

@ -16,6 +16,7 @@
#include "mozilla/Atomics.h" // for Atomic
#include "mozilla/layers/LayersMessages.h" // for ShmemSection
#include "LayersTypes.h"
#include "gfxPrefs.h"
#include "mozilla/layers/AtomicRefCountedWithFinalize.h"
/*
@ -128,7 +129,7 @@ public:
virtual MessageLoop * GetMessageLoop() const = 0;
virtual int32_t GetMaxTextureSize() const;
virtual int32_t GetMaxTextureSize() const { return gfxPrefs::MaxTextureSize(); }
virtual void CancelWaitForRecycle(uint64_t aTextureId) = 0;
};

1
gfx/thebes/gfxPrefs.h
Просмотреть файл

@ -441,7 +441,6 @@ private:
DECL_GFX_PREF(Live, "webgl.can-lose-context-in-foreground", WebGLCanLoseContextInForeground, bool, true);
DECL_GFX_PREF(Live, "webgl.default-no-alpha", WebGLDefaultNoAlpha, bool, false);
DECL_GFX_PREF(Live, "webgl.disable-angle", WebGLDisableANGLE, bool, false);
DECL_GFX_PREF(Live, "webgl.disable-wgl", WebGLDisableWGL, bool, false);
DECL_GFX_PREF(Live, "webgl.disable-extensions", WebGLDisableExtensions, bool, false);
DECL_GFX_PREF(Live, "webgl.dxgl.enabled", WebGLDXGLEnabled, bool, false);
DECL_GFX_PREF(Live, "webgl.dxgl.needs-finish", WebGLDXGLNeedsFinish, bool, false);

3
modules/libpref/init/all.js
Просмотреть файл

@ -4389,7 +4389,6 @@ pref("gl.multithreaded", true);
pref("webgl.force-enabled", false);
pref("webgl.disabled", false);
pref("webgl.disable-angle", false);
pref("webgl.disable-wgl", false);
pref("webgl.min_capability_mode", false);
pref("webgl.disable-extensions", false);
pref("webgl.msaa-force", false);
@ -4427,7 +4426,7 @@ pref("webgl.vendor-string-override", "");
pref("webgl.angle.try-d3d11", true);
pref("webgl.angle.force-d3d11", false);
pref("webgl.angle.force-warp", false);
pref("webgl.dxgl.enabled", true);
pref("webgl.dxgl.enabled", false);
pref("webgl.dxgl.needs-finish", false);
#endif

35
widget/windows/GfxInfo.cpp
Просмотреть файл

@ -377,7 +377,7 @@ GfxInfo::Init()
// Again, assume the worst
mDriverDate.AssignLiteral("01-01-1970");
}
RegCloseKey(key);
RegCloseKey(key);
break;
}
}
@ -891,10 +891,18 @@ GfxInfo::GetGfxDriverInfo()
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorATI), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_DISCOURAGED,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_OGL_ATI_DIS" );
APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Windows,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorATI), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_DISCOURAGED,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_WEBGL_ATI_DIS" );
APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Windows,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorAMD), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_DISCOURAGED,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_OGL_AMD_DIS" );
APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Windows,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorAMD), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_DISCOURAGED,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_WEBGL_AMD_DIS" );
/*
* Intel entries
@ -988,6 +996,10 @@ GfxInfo::GetGfxDriverInfo()
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorIntel), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_OPENGL_LAYERS, nsIGfxInfo::FEATURE_DISCOURAGED,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_INTEL_OGL_DIS" );
APPEND_TO_DRIVER_BLOCKLIST2(OperatingSystem::Windows,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorIntel), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_DISCOURAGED,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_INTEL_WEBGL_DIS" );
/**
* Disable acceleration on Intel HD 3000 for graphics drivers <= 8.15.10.2321.
@ -1112,27 +1124,6 @@ GfxInfo::GetGfxDriverInfo()
nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE, nsIGfxInfo::FEATURE_BLOCKED_DEVICE,
DRIVER_LESS_THAN, GfxDriverInfo::allDriverVersions, "FEATURE_FAILURE_BUG_1153381");
////////////////////////////////////
// WebGL
// Older than 5-15-2016
APPEND_TO_DRIVER_BLOCKLIST2(DRIVER_OS_ALL,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorAMD), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
V(16,200,1010,1002), "WEBGL_NATIVE_GL_OLD_AMD");
// Older than 11-18-2015
APPEND_TO_DRIVER_BLOCKLIST2(DRIVER_OS_ALL,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorIntel), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
V(20,19,15,4331), "WEBGL_NATIVE_GL_OLD_INTEL");
// Older than 2-23-2016
APPEND_TO_DRIVER_BLOCKLIST2(DRIVER_OS_ALL,
(nsAString&) GfxDriverInfo::GetDeviceVendor(VendorNVIDIA), GfxDriverInfo::allDevices,
nsIGfxInfo::FEATURE_WEBGL_OPENGL, nsIGfxInfo::FEATURE_DISCOURAGED, DRIVER_LESS_THAN,
V(10,18,13,6200), "WEBGL_NATIVE_GL_OLD_NVIDIA");
}
return *mDriverInfo;
}