--- a/gfx/gl/GLContext.h
+++ b/gfx/gl/GLContext.h
@@ -194,16 +194,18 @@ class GLContext
: public GLLibraryLoader
, public GenericAtomicRefCounted
, public SupportsWeakPtr<GLContext>
{
public:
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(GLContext)
static MOZ_THREAD_LOCAL(const GLContext*) sCurrentContext;
+ bool mImplicitMakeCurrent;
+
// -----------------------------------------------------------------------------
// basic getters
public:
/**
* Returns true if the context is using ANGLE. This should only be overridden
* for an ANGLE implementation.
*/
@@ -647,136 +649,105 @@ private:
GLsizei length,
const GLchar* message);
// -----------------------------------------------------------------------------
// MOZ_GL_DEBUG implementation
private:
-#undef BEFORE_GL_CALL
-#undef AFTER_GL_CALL
-
-#ifdef MOZ_GL_DEBUG
-
#ifndef MOZ_FUNCTION_NAME
# ifdef __GNUC__
# define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__
# elif defined(_MSC_VER)
# define MOZ_FUNCTION_NAME __FUNCTION__
# else
# define MOZ_FUNCTION_NAME __func__ // defined in C99, supported in various C++ compilers. Just raw function name.
# endif
#endif
- void BeforeGLCall(const char* funcName) {
+#ifdef MOZ_WIDGET_ANDROID
+// Record the name of the GL call for better hang stacks on Android.
+#define ANDROID_ONLY_PROFILER_LABEL AUTO_PROFILER_LABEL(__func__, GRAPHICS);
+#else
+#define ANDROID_ONLY_PROFILER_LABEL
+#endif
+
+#define BEFORE_GL_CALL \
+ ANDROID_ONLY_PROFILER_LABEL \
+ if (BeforeGLCall(MOZ_FUNCTION_NAME)) { \
+ do { } while (0)
+
+#define AFTER_GL_CALL \
+ AfterGLCall(MOZ_FUNCTION_NAME); \
+ } \
+ do { } while (0)
+
+ void BeforeGLCall_Debug(const char* funcName) const;
+ void AfterGLCall_Debug(const char* funcName) const;
+ static void OnImplicitMakeCurrentFailure(const char* funcName);
+
+ bool BeforeGLCall(const char* const funcName) const {
+ if (mImplicitMakeCurrent) {
+ if (MOZ_UNLIKELY( !MakeCurrent() )) {
+ OnImplicitMakeCurrentFailure(funcName);
+ return false;
+ }
+ }
MOZ_ASSERT(IsCurrent());
if (mDebugFlags) {
- FlushErrors();
-
- if (mDebugFlags & DebugFlagTrace) {
- printf_stderr("[gl:%p] > %s\n", this, funcName);
- }
-
- GLContext* tlsContext = (GLContext*)PR_GetThreadPrivate(sCurrentGLContextTLS);
- if (this != tlsContext) {
- printf_stderr("Fatal: %s called on non-current context %p. The"
- " current context for this thread is %p.\n",
- funcName, this, tlsContext);
- MOZ_CRASH("GFX: GLContext is not current.");
- }
+ BeforeGLCall_Debug(funcName);
}
- }
-
- void AfterGLCall(const char* funcName) {
+ return true;
+ }
+
+ void AfterGLCall(const char* const funcName) const {
if (mDebugFlags) {
- // calling fFinish() immediately after every GL call makes sure that if this GL command crashes,
- // the stack trace will actually point to it. Otherwise, OpenGL being an asynchronous API, stack traces
- // tend to be meaningless
- mSymbols.fFinish();
- GLenum err = FlushErrors();
-
- if (mDebugFlags & DebugFlagTrace) {
- printf_stderr("[gl:%p] < %s [%s (0x%04x)]\n", this, funcName,
- GLErrorToString(err), err);
- }
-
- if (err != LOCAL_GL_NO_ERROR &&
- !mLocalErrorScopeStack.size())
- {
- printf_stderr("[gl:%p] %s: Generated unexpected %s error."
- " (0x%04x)\n", this, funcName,
- GLErrorToString(err), err);
-
- if (mDebugFlags & DebugFlagAbortOnError) {
- MOZ_CRASH("Unexpected error with MOZ_GL_DEBUG_ABORT_ON_ERROR. (Run"
- " with MOZ_GL_DEBUG_ABORT_ON_ERROR=0 to disable)");
- }
- }
+ AfterGLCall_Debug(funcName);
}
}
GLContext* TrackingContext()
{
GLContext* tip = this;
while (tip->mSharedContext)
tip = tip->mSharedContext;
return tip;
}
static void AssertNotPassingStackBufferToTheGL(const void* ptr);
-#ifdef MOZ_WIDGET_ANDROID
-// Record the name of the GL call for better hang stacks on Android.
-#define BEFORE_GL_CALL \
- AUTO_PROFILER_LABEL(__func__, GRAPHICS);\
- BeforeGLCall(MOZ_FUNCTION_NAME)
-#else
-#define BEFORE_GL_CALL \
- do { \
- BeforeGLCall(MOZ_FUNCTION_NAME); \
- } while (0)
-#endif
-
-#define AFTER_GL_CALL \
- do { \
- AfterGLCall(MOZ_FUNCTION_NAME); \
- } while (0)
+#ifdef MOZ_GL_DEBUG
#define TRACKING_CONTEXT(a) \
do { \
TrackingContext()->a; \
} while (0)
#define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) AssertNotPassingStackBufferToTheGL(ptr)
-#else // ifdef MOZ_GL_DEBUG
-
-#ifdef MOZ_WIDGET_ANDROID
-// Record the name of the GL call for better hang stacks on Android.
-#define BEFORE_GL_CALL AUTO_PROFILER_LABEL(__func__, GRAPHICS)
-#else
-#define BEFORE_GL_CALL do { } while (0)
-#endif
-#define AFTER_GL_CALL do { } while (0)
-#define TRACKING_CONTEXT(a) do {} while (0)
-#define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) do {} while (0)
-
-#endif // ifdef MOZ_GL_DEBUG
-
#define ASSERT_SYMBOL_PRESENT(func) \
do {\
MOZ_ASSERT(strstr(MOZ_FUNCTION_NAME, #func) != nullptr, "Mismatched symbol check.");\
if (MOZ_UNLIKELY(!mSymbols.func)) {\
printf_stderr("RUNTIME ASSERT: Uninitialized GL function: %s\n", #func);\
MOZ_CRASH("GFX: Uninitialized GL function");\
}\
} while (0)
+#else // ifdef MOZ_GL_DEBUG
+
+#define TRACKING_CONTEXT(a) do {} while (0)
+#define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) do {} while (0)
+#define ASSERT_SYMBOL_PRESENT(func) do {} while (0)
+
+#endif // ifdef MOZ_GL_DEBUG
+
+
// Do whatever setup is necessary to draw to our offscreen FBO, if it's
// bound.
void BeforeGLDrawCall() { }
// Do whatever tear-down is necessary after drawing to our offscreen FBO,
// if it's bound.
void AfterGLDrawCall();
@@ -1177,18 +1148,19 @@ public:
void fGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders) {
BEFORE_GL_CALL;
mSymbols.fGetAttachedShaders(program, maxCount, count, shaders);
OnSyncCall();
AFTER_GL_CALL;
}
GLint fGetAttribLocation(GLuint program, const GLchar* name) {
- BEFORE_GL_CALL;
- GLint retval = mSymbols.fGetAttribLocation(program, name);
+ GLint retval = 0;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fGetAttribLocation(program, name);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
private:
void raw_fGetIntegerv(GLenum pname, GLint* params) {
BEFORE_GL_CALL;
@@ -1230,19 +1202,20 @@ public:
void fGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
BEFORE_GL_CALL;
mSymbols.fGetBufferParameteriv(target, pname, params);
OnSyncCall();
AFTER_GL_CALL;
}
GLuint fGetDebugMessageLog(GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog) {
+ GLuint ret = 0;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetDebugMessageLog);
- GLuint ret = mSymbols.fGetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog);
+ ret = mSymbols.fGetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
void fGetPointerv(GLenum pname, GLvoid** params) {
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetPointerv);
@@ -1301,18 +1274,19 @@ public:
void fTexParameterf(GLenum target, GLenum pname, GLfloat param) {
BEFORE_GL_CALL;
mSymbols.fTexParameterf(target, pname, param);
AFTER_GL_CALL;
}
const GLubyte* fGetString(GLenum name) {
- BEFORE_GL_CALL;
- const GLubyte* result = mSymbols.fGetString(name);
+ const GLubyte* result = nullptr;
+ BEFORE_GL_CALL;
+ result = mSymbols.fGetString(name);
OnSyncCall();
AFTER_GL_CALL;
return result;
}
void fGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* img) {
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetTexImage);
@@ -1362,18 +1336,19 @@ public:
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetUniformuiv);
mSymbols.fGetUniformuiv(program, location, params);
OnSyncCall();
AFTER_GL_CALL;
}
GLint fGetUniformLocation (GLint programObj, const GLchar* name) {
- BEFORE_GL_CALL;
- GLint retval = mSymbols.fGetUniformLocation(programObj, name);
+ GLint retval = 0;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fGetUniformLocation(programObj, name);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
void fGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* retval) {
BEFORE_GL_CALL;
mSymbols.fGetVertexAttribfv(index, pname, retval);
@@ -1397,47 +1372,52 @@ public:
void fHint(GLenum target, GLenum mode) {
BEFORE_GL_CALL;
mSymbols.fHint(target, mode);
AFTER_GL_CALL;
}
realGLboolean fIsBuffer(GLuint buffer) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsBuffer(buffer);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsBuffer(buffer);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
realGLboolean fIsEnabled(GLenum capability) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsEnabled(capability);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsEnabled(capability);
AFTER_GL_CALL;
return retval;
}
realGLboolean fIsProgram(GLuint program) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsProgram(program);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsProgram(program);
AFTER_GL_CALL;
return retval;
}
realGLboolean fIsShader(GLuint shader) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsShader(shader);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsShader(shader);
AFTER_GL_CALL;
return retval;
}
realGLboolean fIsTexture(GLuint texture) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsTexture(texture);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsTexture(texture);
AFTER_GL_CALL;
return retval;
}
void fLineWidth(GLfloat width) {
BEFORE_GL_CALL;
mSymbols.fLineWidth(width);
AFTER_GL_CALL;
@@ -1867,16 +1847,33 @@ public:
}
void fVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
BEFORE_GL_CALL;
mSymbols.fVertexPointer(size, type, stride, pointer);
AFTER_GL_CALL;
}
+ void fViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+ if (mViewportRect[0] == x &&
+ mViewportRect[1] == y &&
+ mViewportRect[2] == width &&
+ mViewportRect[3] == height)
+ {
+ return;
+ }
+ mViewportRect[0] = x;
+ mViewportRect[1] = y;
+ mViewportRect[2] = width;
+ mViewportRect[3] = height;
+ BEFORE_GL_CALL;
+ mSymbols.fViewport(x, y, width, height);
+ AFTER_GL_CALL;
+ }
+
void fCompileShader(GLuint shader) {
BEFORE_GL_CALL;
mSymbols.fCompileShader(shader);
AFTER_GL_CALL;
}
private:
@@ -1957,18 +1954,19 @@ private:
public:
void fBindRenderbuffer(GLenum target, GLuint renderbuffer) {
BEFORE_GL_CALL;
mSymbols.fBindRenderbuffer(target, renderbuffer);
AFTER_GL_CALL;
}
GLenum fCheckFramebufferStatus(GLenum target) {
- BEFORE_GL_CALL;
- GLenum retval = mSymbols.fCheckFramebufferStatus(target);
+ GLenum retval = 0;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fCheckFramebufferStatus(target);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
void fFramebufferRenderbuffer(GLenum target, GLenum attachmentPoint, GLenum renderbufferTarget, GLuint renderbuffer) {
BEFORE_GL_CALL;
mSymbols.fFramebufferRenderbuffer(target, attachmentPoint, renderbufferTarget, renderbuffer);
@@ -2001,27 +1999,29 @@ public:
void fGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* value) {
BEFORE_GL_CALL;
mSymbols.fGetRenderbufferParameteriv(target, pname, value);
OnSyncCall();
AFTER_GL_CALL;
}
realGLboolean fIsFramebuffer (GLuint framebuffer) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsFramebuffer(framebuffer);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsFramebuffer(framebuffer);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
public:
realGLboolean fIsRenderbuffer (GLuint renderbuffer) {
- BEFORE_GL_CALL;
- realGLboolean retval = mSymbols.fIsRenderbuffer(renderbuffer);
+ realGLboolean retval = false;
+ BEFORE_GL_CALL;
+ retval = mSymbols.fIsRenderbuffer(renderbuffer);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
void fRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) {
BEFORE_GL_CALL;
mSymbols.fRenderbufferStorage(target, internalFormat, width, height);
@@ -2078,44 +2078,48 @@ public:
if (IsGLES()) {
raw_fClearDepthf(v);
} else {
raw_fClearDepth(v);
}
}
void* fMapBuffer(GLenum target, GLenum access) {
+ void* ret = nullptr;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fMapBuffer);
- void* ret = mSymbols.fMapBuffer(target, access);
+ ret = mSymbols.fMapBuffer(target, access);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
realGLboolean fUnmapBuffer(GLenum target) {
+ realGLboolean ret = false;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fUnmapBuffer);
- realGLboolean ret = mSymbols.fUnmapBuffer(target);
+ ret = mSymbols.fUnmapBuffer(target);
AFTER_GL_CALL;
return ret;
}
private:
GLuint raw_fCreateProgram() {
- BEFORE_GL_CALL;
- GLuint ret = mSymbols.fCreateProgram();
+ GLuint ret = 0;
+ BEFORE_GL_CALL;
+ ret = mSymbols.fCreateProgram();
AFTER_GL_CALL;
return ret;
}
GLuint raw_fCreateShader(GLenum t) {
- BEFORE_GL_CALL;
- GLuint ret = mSymbols.fCreateShader(t);
+ GLuint ret = 0;
+ BEFORE_GL_CALL;
+ ret = mSymbols.fCreateShader(t);
AFTER_GL_CALL;
return ret;
}
void raw_fGenBuffers(GLsizei n, GLuint* names) {
BEFORE_GL_CALL;
mSymbols.fGenBuffers(n, names);
OnSyncCall();
@@ -2238,57 +2242,61 @@ public:
}
void fDeleteTextures(GLsizei n, const GLuint* names) {
raw_fDeleteTextures(n, names);
TRACKING_CONTEXT(DeletedTextures(this, n, names));
}
GLenum fGetGraphicsResetStatus() {
+ GLenum ret = 0;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetGraphicsResetStatus);
- GLenum ret = mSymbols.fGetGraphicsResetStatus();
+ ret = mSymbols.fGetGraphicsResetStatus();
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
// -----------------------------------------------------------------------------
// Extension ARB_sync (GL)
public:
GLsync fFenceSync(GLenum condition, GLbitfield flags) {
+ GLsync ret = 0;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fFenceSync);
- GLsync ret = mSymbols.fFenceSync(condition, flags);
+ ret = mSymbols.fFenceSync(condition, flags);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
realGLboolean fIsSync(GLsync sync) {
+ realGLboolean ret = false;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fIsSync);
- realGLboolean ret = mSymbols.fIsSync(sync);
+ ret = mSymbols.fIsSync(sync);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
void fDeleteSync(GLsync sync) {
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fDeleteSync);
mSymbols.fDeleteSync(sync);
AFTER_GL_CALL;
}
GLenum fClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+ GLenum ret = 0;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fClientWaitSync);
- GLenum ret = mSymbols.fClientWaitSync(sync, flags, timeout);
+ ret = mSymbols.fClientWaitSync(sync, flags, timeout);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
void fWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fWaitSync);
@@ -2556,19 +2564,20 @@ public:
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fUniform4uiv);
mSymbols.fUniform4uiv(location, count, value);
AFTER_GL_CALL;
}
GLint fGetFragDataLocation(GLuint program, const GLchar* name)
{
+ GLint result = 0;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetFragDataLocation);
- GLint result = mSymbols.fGetFragDataLocation(program, name);
+ result = mSymbols.fGetFragDataLocation(program, name);
OnSyncCall();
AFTER_GL_CALL;
return result;
}
// -----------------------------------------------------------------------------
// Package XXX_instanced_arrays
@@ -2653,19 +2662,20 @@ public:
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetQueryObjectuiv);
mSymbols.fGetQueryObjectuiv(id, pname, params);
OnSyncCall();
AFTER_GL_CALL;
}
realGLboolean fIsQuery(GLuint query) {
+ realGLboolean retval = false;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fIsQuery);
- realGLboolean retval = mSymbols.fIsQuery(query);
+ retval = mSymbols.fIsQuery(query);
OnSyncCall();
AFTER_GL_CALL;
return retval;
}
// -----------------------------------------------------------------------------
// Package XXX_get_query_object_i64v
/**
@@ -2745,19 +2755,20 @@ public:
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fDeleteTransformFeedbacks);
mSymbols.fDeleteTransformFeedbacks(n, ids);
AFTER_GL_CALL;
}
realGLboolean fIsTransformFeedback(GLuint id)
{
+ realGLboolean result = false;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fIsTransformFeedback);
- realGLboolean result = mSymbols.fIsTransformFeedback(id);
+ result = mSymbols.fIsTransformFeedback(id);
OnSyncCall();
AFTER_GL_CALL;
return result;
}
void fBindTransformFeedback(GLenum target, GLuint id)
{
BEFORE_GL_CALL;
@@ -2856,19 +2867,20 @@ public:
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGenVertexArrays);
mSymbols.fGenVertexArrays(n, arrays);
AFTER_GL_CALL;
}
realGLboolean fIsVertexArray(GLuint array)
{
+ realGLboolean ret = false;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fIsVertexArray);
- realGLboolean ret = mSymbols.fIsVertexArray(array);
+ ret = mSymbols.fIsVertexArray(array);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
// -----------------------------------------------------------------------------
// Extension NV_fence
public:
@@ -2893,38 +2905,40 @@ public:
ASSERT_SYMBOL_PRESENT(fSetFence);
BEFORE_GL_CALL;
mSymbols.fSetFence(fence, condition);
AFTER_GL_CALL;
}
realGLboolean fTestFence(GLuint fence)
{
+ realGLboolean ret = false;
ASSERT_SYMBOL_PRESENT(fTestFence);
BEFORE_GL_CALL;
- realGLboolean ret = mSymbols.fTestFence(fence);
+ ret = mSymbols.fTestFence(fence);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
void fFinishFence(GLuint fence)
{
ASSERT_SYMBOL_PRESENT(fFinishFence);
BEFORE_GL_CALL;
mSymbols.fFinishFence(fence);
OnSyncCall();
AFTER_GL_CALL;
}
realGLboolean fIsFence(GLuint fence)
{
+ realGLboolean ret = false;
ASSERT_SYMBOL_PRESENT(fIsFence);
BEFORE_GL_CALL;
- realGLboolean ret = mSymbols.fIsFence(fence);
+ ret = mSymbols.fIsFence(fence);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
void fGetFenceiv(GLuint fence, GLenum pname, GLint* params)
{
ASSERT_SYMBOL_PRESENT(fGetFenceiv);
@@ -2959,19 +2973,20 @@ public:
// -----------------------------------------------------------------------------
// Core GL & Extension ARB_map_buffer_range
public:
void* fMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
GLbitfield access)
{
+ void* data = nullptr;
ASSERT_SYMBOL_PRESENT(fMapBufferRange);
BEFORE_GL_CALL;
- void* data = mSymbols.fMapBufferRange(target, offset, length, access);
+ data = mSymbols.fMapBufferRange(target, offset, length, access);
OnSyncCall();
AFTER_GL_CALL;
return data;
}
void fFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {
ASSERT_SYMBOL_PRESENT(fFlushMappedBufferRange);
BEFORE_GL_CALL;
@@ -2996,19 +3011,20 @@ public:
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fDeleteSamplers);
mSymbols.fDeleteSamplers(count, samplers);
AFTER_GL_CALL;
}
realGLboolean fIsSampler(GLuint sampler)
{
+ realGLboolean result = false;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fIsSampler);
- realGLboolean result = mSymbols.fIsSampler(sampler);
+ result = mSymbols.fIsSampler(sampler);
OnSyncCall();
AFTER_GL_CALL;
return result;
}
void fBindSampler(GLuint unit, GLuint sampler)
{
BEFORE_GL_CALL;
@@ -3085,19 +3101,20 @@ public:
ASSERT_SYMBOL_PRESENT(fGetActiveUniformsiv);
BEFORE_GL_CALL;
mSymbols.fGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
OnSyncCall();
AFTER_GL_CALL;
}
GLuint fGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) {
+ GLuint result = 0;
ASSERT_SYMBOL_PRESENT(fGetUniformBlockIndex);
BEFORE_GL_CALL;
- GLuint result = mSymbols.fGetUniformBlockIndex(program, uniformBlockName);
+ result = mSymbols.fGetUniformBlockIndex(program, uniformBlockName);
OnSyncCall();
AFTER_GL_CALL;
return result;
}
void fGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
GLenum pname, GLint* params)
{
@@ -3214,19 +3231,20 @@ public:
format, imageSize, data);
AFTER_GL_CALL;
}
// -----------------------------------------------------------------------------
// GL3+, ES3+
const GLubyte* fGetStringi(GLenum name, GLuint index) {
+ const GLubyte* ret = nullptr;
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fGetStringi);
- const GLubyte* ret = mSymbols.fGetStringi(name, index);
+ ret = mSymbols.fGetStringi(name, index);
OnSyncCall();
AFTER_GL_CALL;
return ret;
}
// -----------------------------------------------------------------------------
// APPLE_framebuffer_multisample
@@ -3242,16 +3260,22 @@ public:
void fPrimitiveRestartIndex(GLuint index) {
BEFORE_GL_CALL;
ASSERT_SYMBOL_PRESENT(fPrimitiveRestartIndex);
mSymbols.fPrimitiveRestartIndex(index);
AFTER_GL_CALL;
}
+#undef BEFORE_GL_CALL
+#undef AFTER_GL_CALL
+#undef ASSERT_SYMBOL_PRESENT
+// #undef TRACKING_CONTEXT // Needed in GLContext.cpp
+#undef ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL
+
// -----------------------------------------------------------------------------
// Constructor
protected:
explicit GLContext(CreateContextFlags flags, const SurfaceCaps& caps,
GLContext* sharedContext = nullptr,
bool isOffscreen = false, bool canUseTLSIsCurrent = false);
@@ -3587,35 +3611,16 @@ protected:
}
public:
GLsizei MaxSamples() const {
return mMaxSamples;
}
- void fViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
- if (mViewportRect[0] == x &&
- mViewportRect[1] == y &&
- mViewportRect[2] == width &&
- mViewportRect[3] == height)
- {
- return;
- }
- mViewportRect[0] = x;
- mViewportRect[1] = y;
- mViewportRect[2] = width;
- mViewportRect[3] = height;
- BEFORE_GL_CALL;
- mSymbols.fViewport(x, y, width, height);
- AFTER_GL_CALL;
- }
-
-#undef ASSERT_SYMBOL_PRESENT
-
#ifdef MOZ_GL_DEBUG
void CreatedProgram(GLContext* aOrigin, GLuint aName);
void CreatedShader(GLContext* aOrigin, GLuint aName);
void CreatedBuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
void CreatedQueries(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
void CreatedTextures(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
void CreatedFramebuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
void CreatedRenderbuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);