reduce code size in GrGLTestInterface.o and GrGLAssembleInterface.o

All these std::function instantiations fill the object files up with
almost 1MB of boilerplate generated code.  I think we can do better by
implementing GrGLFunction as its own std::function-like type with much
less overhead, bringing the total object file size down to about 200K.

This reduces DM from 28780344 to 27726144 on my Mac, a touch above 1MB.

Change-Id: I219a86737d1dfb8b68e4eb47b51a8a98b18ff282
Reviewed-on: https://skia-review.googlesource.com/20551
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Mike Klein <mtklein@chromium.org>

1 files changed, 347 insertions, 347 deletions

diff --git a/src/gpu/gl/GrGLInterface.cpp b/src/gpu/gl/GrGLInterface.cpp
index dcad07e1f2..5d03b2b720 100644
--- a/src/gpu/gl/GrGLInterface.cpp
+++ b/src/gpu/gl/GrGLInterface.cpp
@@ -64,108 +64,108 @@ bool GrGLInterface::validate() const {
     }
 
     // functions that are always required
-    if (nullptr == fFunctions.fActiveTexture ||
-        nullptr == fFunctions.fAttachShader ||
-        nullptr == fFunctions.fBindAttribLocation ||
-        nullptr == fFunctions.fBindBuffer ||
-        nullptr == fFunctions.fBindTexture ||
-        nullptr == fFunctions.fBlendColor ||      // -> GL >= 1.4 or extension, ES >= 2.0
-        nullptr == fFunctions.fBlendEquation ||   // -> GL >= 1.4 or extension, ES >= 2.0
-        nullptr == fFunctions.fBlendFunc ||
-        nullptr == fFunctions.fBufferData ||
-        nullptr == fFunctions.fBufferSubData ||
-        nullptr == fFunctions.fClear ||
-        nullptr == fFunctions.fClearColor ||
-        nullptr == fFunctions.fClearStencil ||
-        nullptr == fFunctions.fColorMask ||
-        nullptr == fFunctions.fCompileShader ||
-        nullptr == fFunctions.fCompressedTexImage2D ||
-        nullptr == fFunctions.fCompressedTexSubImage2D ||
-        nullptr == fFunctions.fCopyTexSubImage2D ||
-        nullptr == fFunctions.fCreateProgram ||
-        nullptr == fFunctions.fCreateShader ||
-        nullptr == fFunctions.fCullFace ||
-        nullptr == fFunctions.fDeleteBuffers ||
-        nullptr == fFunctions.fDeleteProgram ||
-        nullptr == fFunctions.fDeleteShader ||
-        nullptr == fFunctions.fDeleteTextures ||
-        nullptr == fFunctions.fDepthMask ||
-        nullptr == fFunctions.fDisable ||
-        nullptr == fFunctions.fDisableVertexAttribArray ||
-        nullptr == fFunctions.fDrawArrays ||
-        nullptr == fFunctions.fDrawElements ||
-        nullptr == fFunctions.fEnable ||
-        nullptr == fFunctions.fEnableVertexAttribArray ||
-        nullptr == fFunctions.fFrontFace ||
-        nullptr == fFunctions.fGenBuffers ||
-        nullptr == fFunctions.fGenTextures ||
-        nullptr == fFunctions.fGetBufferParameteriv ||
-        nullptr == fFunctions.fGenerateMipmap ||
-        nullptr == fFunctions.fGetError ||
-        nullptr == fFunctions.fGetIntegerv ||
-        nullptr == fFunctions.fGetProgramInfoLog ||
-        nullptr == fFunctions.fGetProgramiv ||
-        nullptr == fFunctions.fGetShaderInfoLog ||
-        nullptr == fFunctions.fGetShaderiv ||
-        nullptr == fFunctions.fGetString ||
-        nullptr == fFunctions.fGetUniformLocation ||
-        nullptr == fFunctions.fIsTexture ||
-        nullptr == fFunctions.fLinkProgram ||
-        nullptr == fFunctions.fLineWidth ||
-        nullptr == fFunctions.fPixelStorei ||
-        nullptr == fFunctions.fReadPixels ||
-        nullptr == fFunctions.fScissor ||
-        nullptr == fFunctions.fShaderSource ||
-        nullptr == fFunctions.fStencilFunc ||
-        nullptr == fFunctions.fStencilFuncSeparate ||
-        nullptr == fFunctions.fStencilMask ||
-        nullptr == fFunctions.fStencilMaskSeparate ||
-        nullptr == fFunctions.fStencilOp ||
-        nullptr == fFunctions.fStencilOpSeparate ||
-        nullptr == fFunctions.fTexImage2D ||
-        nullptr == fFunctions.fTexParameteri ||
-        nullptr == fFunctions.fTexParameteriv ||
-        nullptr == fFunctions.fTexSubImage2D ||
-        nullptr == fFunctions.fUniform1f ||
-        nullptr == fFunctions.fUniform1i ||
-        nullptr == fFunctions.fUniform1fv ||
-        nullptr == fFunctions.fUniform1iv ||
-        nullptr == fFunctions.fUniform2f ||
-        nullptr == fFunctions.fUniform2i ||
-        nullptr == fFunctions.fUniform2fv ||
-        nullptr == fFunctions.fUniform2iv ||
-        nullptr == fFunctions.fUniform3f ||
-        nullptr == fFunctions.fUniform3i ||
-        nullptr == fFunctions.fUniform3fv ||
-        nullptr == fFunctions.fUniform3iv ||
-        nullptr == fFunctions.fUniform4f ||
-        nullptr == fFunctions.fUniform4i ||
-        nullptr == fFunctions.fUniform4fv ||
-        nullptr == fFunctions.fUniform4iv ||
-        nullptr == fFunctions.fUniformMatrix2fv ||
-        nullptr == fFunctions.fUniformMatrix3fv ||
-        nullptr == fFunctions.fUniformMatrix4fv ||
-        nullptr == fFunctions.fUseProgram ||
-        nullptr == fFunctions.fVertexAttrib1f ||
-        nullptr == fFunctions.fVertexAttrib2fv ||
-        nullptr == fFunctions.fVertexAttrib3fv ||
-        nullptr == fFunctions.fVertexAttrib4fv ||
-        nullptr == fFunctions.fVertexAttribPointer ||
-        nullptr == fFunctions.fViewport ||
-        nullptr == fFunctions.fBindFramebuffer ||
-        nullptr == fFunctions.fBindRenderbuffer ||
-        nullptr == fFunctions.fCheckFramebufferStatus ||
-        nullptr == fFunctions.fDeleteFramebuffers ||
-        nullptr == fFunctions.fDeleteRenderbuffers ||
-        nullptr == fFunctions.fFinish ||
-        nullptr == fFunctions.fFlush ||
-        nullptr == fFunctions.fFramebufferRenderbuffer ||
-        nullptr == fFunctions.fFramebufferTexture2D ||
-        nullptr == fFunctions.fGetFramebufferAttachmentParameteriv ||
-        nullptr == fFunctions.fGetRenderbufferParameteriv ||
-        nullptr == fFunctions.fGenFramebuffers ||
-        nullptr == fFunctions.fGenRenderbuffers ||
-        nullptr == fFunctions.fRenderbufferStorage) {
+    if (!fFunctions.fActiveTexture ||
+        !fFunctions.fAttachShader ||
+        !fFunctions.fBindAttribLocation ||
+        !fFunctions.fBindBuffer ||
+        !fFunctions.fBindTexture ||
+        !fFunctions.fBlendColor ||      // -> GL >= 1.4 or extension, ES >= 2.0
+        !fFunctions.fBlendEquation ||   // -> GL >= 1.4 or extension, ES >= 2.0
+        !fFunctions.fBlendFunc ||
+        !fFunctions.fBufferData ||
+        !fFunctions.fBufferSubData ||
+        !fFunctions.fClear ||
+        !fFunctions.fClearColor ||
+        !fFunctions.fClearStencil ||
+        !fFunctions.fColorMask ||
+        !fFunctions.fCompileShader ||
+        !fFunctions.fCompressedTexImage2D ||
+        !fFunctions.fCompressedTexSubImage2D ||
+        !fFunctions.fCopyTexSubImage2D ||
+        !fFunctions.fCreateProgram ||
+        !fFunctions.fCreateShader ||
+        !fFunctions.fCullFace ||
+        !fFunctions.fDeleteBuffers ||
+        !fFunctions.fDeleteProgram ||
+        !fFunctions.fDeleteShader ||
+        !fFunctions.fDeleteTextures ||
+        !fFunctions.fDepthMask ||
+        !fFunctions.fDisable ||
+        !fFunctions.fDisableVertexAttribArray ||
+        !fFunctions.fDrawArrays ||
+        !fFunctions.fDrawElements ||
+        !fFunctions.fEnable ||
+        !fFunctions.fEnableVertexAttribArray ||
+        !fFunctions.fFrontFace ||
+        !fFunctions.fGenBuffers ||
+        !fFunctions.fGenTextures ||
+        !fFunctions.fGetBufferParameteriv ||
+        !fFunctions.fGenerateMipmap ||
+        !fFunctions.fGetError ||
+        !fFunctions.fGetIntegerv ||
+        !fFunctions.fGetProgramInfoLog ||
+        !fFunctions.fGetProgramiv ||
+        !fFunctions.fGetShaderInfoLog ||
+        !fFunctions.fGetShaderiv ||
+        !fFunctions.fGetString ||
+        !fFunctions.fGetUniformLocation ||
+        !fFunctions.fIsTexture ||
+        !fFunctions.fLinkProgram ||
+        !fFunctions.fLineWidth ||
+        !fFunctions.fPixelStorei ||
+        !fFunctions.fReadPixels ||
+        !fFunctions.fScissor ||
+        !fFunctions.fShaderSource ||
+        !fFunctions.fStencilFunc ||
+        !fFunctions.fStencilFuncSeparate ||
+        !fFunctions.fStencilMask ||
+        !fFunctions.fStencilMaskSeparate ||
+        !fFunctions.fStencilOp ||
+        !fFunctions.fStencilOpSeparate ||
+        !fFunctions.fTexImage2D ||
+        !fFunctions.fTexParameteri ||
+        !fFunctions.fTexParameteriv ||
+        !fFunctions.fTexSubImage2D ||
+        !fFunctions.fUniform1f ||
+        !fFunctions.fUniform1i ||
+        !fFunctions.fUniform1fv ||
+        !fFunctions.fUniform1iv ||
+        !fFunctions.fUniform2f ||
+        !fFunctions.fUniform2i ||
+        !fFunctions.fUniform2fv ||
+        !fFunctions.fUniform2iv ||
+        !fFunctions.fUniform3f ||
+        !fFunctions.fUniform3i ||
+        !fFunctions.fUniform3fv ||
+        !fFunctions.fUniform3iv ||
+        !fFunctions.fUniform4f ||
+        !fFunctions.fUniform4i ||
+        !fFunctions.fUniform4fv ||
+        !fFunctions.fUniform4iv ||
+        !fFunctions.fUniformMatrix2fv ||
+        !fFunctions.fUniformMatrix3fv ||
+        !fFunctions.fUniformMatrix4fv ||
+        !fFunctions.fUseProgram ||
+        !fFunctions.fVertexAttrib1f ||
+        !fFunctions.fVertexAttrib2fv ||
+        !fFunctions.fVertexAttrib3fv ||
+        !fFunctions.fVertexAttrib4fv ||
+        !fFunctions.fVertexAttribPointer ||
+        !fFunctions.fViewport ||
+        !fFunctions.fBindFramebuffer ||
+        !fFunctions.fBindRenderbuffer ||
+        !fFunctions.fCheckFramebufferStatus ||
+        !fFunctions.fDeleteFramebuffers ||
+        !fFunctions.fDeleteRenderbuffers ||
+        !fFunctions.fFinish ||
+        !fFunctions.fFlush ||
+        !fFunctions.fFramebufferRenderbuffer ||
+        !fFunctions.fFramebufferTexture2D ||
+        !fFunctions.fGetFramebufferAttachmentParameteriv ||
+        !fFunctions.fGetRenderbufferParameteriv ||
+        !fFunctions.fGenFramebuffers ||
+        !fFunctions.fGenRenderbuffers ||
+        !fFunctions.fRenderbufferStorage) {
         RETURN_FALSE_INTERFACE
     }
 
@@ -182,20 +182,20 @@ bool GrGLInterface::validate() const {
     // On the desktop we assume they are available if the extension
     // is present or GL version is high enough.
     if (kGL_GrGLStandard == fStandard) {
-        if (glVer >= GR_GL_VER(3,0) && nullptr == fFunctions.fBindFragDataLocation) {
+        if (glVer >= GR_GL_VER(3,0) && !fFunctions.fBindFragDataLocation) {
             RETURN_FALSE_INTERFACE
         }
 
         if (glVer >= GR_GL_VER(3,3) ||
             fExtensions.has("GL_ARB_timer_query") ||
             fExtensions.has("GL_EXT_timer_query")) {
-            if (nullptr == fFunctions.fGetQueryObjecti64v ||
-                nullptr == fFunctions.fGetQueryObjectui64v) {
+            if (!fFunctions.fGetQueryObjecti64v ||
+                !fFunctions.fGetQueryObjectui64v) {
                 RETURN_FALSE_INTERFACE
             }
         }
         if (glVer >= GR_GL_VER(3,3) || fExtensions.has("GL_ARB_timer_query")) {
-            if (nullptr == fFunctions.fQueryCounter) {
+            if (!fFunctions.fQueryCounter) {
                 RETURN_FALSE_INTERFACE
             }
         }
@@ -203,27 +203,27 @@ bool GrGLInterface::validate() const {
 
     // part of desktop GL, but not ES
     if (kGL_GrGLStandard == fStandard &&
-        (nullptr == fFunctions.fDrawBuffer ||
-         nullptr == fFunctions.fPolygonMode)) {
+        (!fFunctions.fDrawBuffer ||
+         !fFunctions.fPolygonMode)) {
         RETURN_FALSE_INTERFACE
     }
 
     // ES 3.0 (or ES 2.0 extended) has glDrawBuffers but not glDrawBuffer
     if (kGL_GrGLStandard == fStandard || glVer >= GR_GL_VER(3,0)) {
-        if (nullptr == fFunctions.fDrawBuffers) {
+        if (!fFunctions.fDrawBuffers) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (kGL_GrGLStandard == fStandard || glVer >= GR_GL_VER(3,0)) {
-        if (nullptr == fFunctions.fReadBuffer) {
+        if (!fFunctions.fReadBuffer) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     // glGetTexLevelParameteriv was added to ES in 3.1.
     if (kGL_GrGLStandard == fStandard || glVer >= GR_GL_VER(3,1)) {
-        if (nullptr == fFunctions.fGetTexLevelParameteriv) {
+        if (!fFunctions.fGetTexLevelParameteriv) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -234,12 +234,12 @@ bool GrGLInterface::validate() const {
         if (glVer >= GR_GL_VER(4,2) ||
             fExtensions.has("GL_ARB_texture_storage") ||
             fExtensions.has("GL_EXT_texture_storage")) {
-            if (nullptr == fFunctions.fTexStorage2D) {
+            if (!fFunctions.fTexStorage2D) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else if (glVer >= GR_GL_VER(3,0) || fExtensions.has("GL_EXT_texture_storage")) {
-        if (nullptr == fFunctions.fTexStorage2D) {
+        if (!fFunctions.fTexStorage2D) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -249,25 +249,25 @@ bool GrGLInterface::validate() const {
         if (glVer >= GR_GL_VER(4,5) ||
             fExtensions.has("GL_ARB_texture_barrier") ||
             fExtensions.has("GL_NV_texture_barrier")) {
-            if (nullptr == fFunctions.fTextureBarrier) {
+            if (!fFunctions.fTextureBarrier) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else if (fExtensions.has("GL_NV_texture_barrier")) {
-        if (nullptr == fFunctions.fTextureBarrier) {
+        if (!fFunctions.fTextureBarrier) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (fExtensions.has("GL_KHR_blend_equation_advanced") ||
         fExtensions.has("GL_NV_blend_equation_advanced")) {
-        if (nullptr == fFunctions.fBlendBarrier) {
+        if (!fFunctions.fBlendBarrier) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (fExtensions.has("GL_EXT_discard_framebuffer")) {
-        if (nullptr == fFunctions.fDiscardFramebuffer) {
+        if (!fFunctions.fDiscardFramebuffer) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -276,18 +276,18 @@ bool GrGLInterface::validate() const {
     if (kGL_GrGLStandard == fStandard || glVer >= GR_GL_VER(3,0) ||
         fExtensions.has("GL_EXT_occlusion_query_boolean")) {
 #if 0 // Not yet added to chrome's bindings.
-        if (nullptr == fFunctions.fGenQueries ||
-            nullptr == fFunctions.fDeleteQueries ||
-            nullptr == fFunctions.fBeginQuery ||
-            nullptr == fFunctions.fEndQuery ||
-            nullptr == fFunctions.fGetQueryiv ||
-            nullptr == fFunctions.fGetQueryObjectuiv) {
+        if (!fFunctions.fGenQueries ||
+            !fFunctions.fDeleteQueries ||
+            !fFunctions.fBeginQuery ||
+            !fFunctions.fEndQuery ||
+            !fFunctions.fGetQueryiv ||
+            !fFunctions.fGetQueryObjectuiv) {
             RETURN_FALSE_INTERFACE
         }
 #endif
     }
     // glGetQueryObjectiv doesn't exist in ES.
-    if (kGL_GrGLStandard == fStandard && nullptr == fFunctions.fGetQueryObjectiv) {
+    if (kGL_GrGLStandard == fStandard && !fFunctions.fGetQueryObjectiv) {
         RETURN_FALSE_INTERFACE
     }
 
@@ -295,46 +295,46 @@ bool GrGLInterface::validate() const {
     if (kGL_GrGLStandard == fStandard) {
         // GL 3.0 and the ARB extension have multisample + blit
         if (glVer >= GR_GL_VER(3,0) || fExtensions.has("GL_ARB_framebuffer_object")) {
-            if (nullptr == fFunctions.fRenderbufferStorageMultisample ||
-                nullptr == fFunctions.fBlitFramebuffer) {
+            if (!fFunctions.fRenderbufferStorageMultisample ||
+                !fFunctions.fBlitFramebuffer) {
                 RETURN_FALSE_INTERFACE
             }
         } else {
             if (fExtensions.has("GL_EXT_framebuffer_blit") &&
-                nullptr == fFunctions.fBlitFramebuffer) {
+                !fFunctions.fBlitFramebuffer) {
                 RETURN_FALSE_INTERFACE
             }
             if (fExtensions.has("GL_EXT_framebuffer_multisample") &&
-                nullptr == fFunctions.fRenderbufferStorageMultisample) {
+                !fFunctions.fRenderbufferStorageMultisample) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else {
         if (glVer >= GR_GL_VER(3,0) || fExtensions.has("GL_CHROMIUM_framebuffer_multisample")) {
-            if (nullptr == fFunctions.fRenderbufferStorageMultisample ||
-                nullptr == fFunctions.fBlitFramebuffer) {
+            if (!fFunctions.fRenderbufferStorageMultisample ||
+                !fFunctions.fBlitFramebuffer) {
                 RETURN_FALSE_INTERFACE
             }
         } else {
             if (fExtensions.has("GL_ANGLE_framebuffer_multisample") &&
-                nullptr == fFunctions.fRenderbufferStorageMultisample) {
+                !fFunctions.fRenderbufferStorageMultisample) {
                 RETURN_FALSE_INTERFACE
             }
             if (fExtensions.has("GL_ANGLE_framebuffer_blit") &&
-                nullptr == fFunctions.fBlitFramebuffer) {
+                !fFunctions.fBlitFramebuffer) {
                 RETURN_FALSE_INTERFACE
             }
         }
         if (fExtensions.has("GL_APPLE_framebuffer_multisample")) {
-            if (nullptr == fFunctions.fRenderbufferStorageMultisampleES2APPLE ||
-                nullptr == fFunctions.fResolveMultisampleFramebuffer) {
+            if (!fFunctions.fRenderbufferStorageMultisampleES2APPLE ||
+                !fFunctions.fResolveMultisampleFramebuffer) {
                 RETURN_FALSE_INTERFACE
             }
         }
         if (fExtensions.has("GL_IMG_multisampled_render_to_texture") ||
             fExtensions.has("GL_EXT_multisampled_render_to_texture")) {
-            if (nullptr == fFunctions.fRenderbufferStorageMultisampleES2EXT ||
-                nullptr == fFunctions.fFramebufferTexture2DMultisample) {
+            if (!fFunctions.fRenderbufferStorageMultisampleES2EXT ||
+                !fFunctions.fFramebufferTexture2DMultisample) {
                 RETURN_FALSE_INTERFACE
             }
         }
@@ -344,8 +344,8 @@ bool GrGLInterface::validate() const {
     // buffer mapping was part of original VBO extension
     // which we require.
     if (kGL_GrGLStandard == fStandard || fExtensions.has("GL_OES_mapbuffer")) {
-        if (nullptr == fFunctions.fMapBuffer ||
-            nullptr == fFunctions.fUnmapBuffer) {
+        if (!fFunctions.fMapBuffer ||
+            !fFunctions.fUnmapBuffer) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -353,14 +353,14 @@ bool GrGLInterface::validate() const {
     // Dual source blending
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3,3) || fExtensions.has("GL_ARB_blend_func_extended")) {
-            if (nullptr == fFunctions.fBindFragDataLocationIndexed) {
+            if (!fFunctions.fBindFragDataLocationIndexed) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else {
         if (glVer >= GR_GL_VER(3,0) && fExtensions.has("GL_EXT_blend_func_extended")) {
-            if (nullptr == fFunctions.fBindFragDataLocation ||
-                nullptr == fFunctions.fBindFragDataLocationIndexed) {
+            if (!fFunctions.fBindFragDataLocation ||
+                !fFunctions.fBindFragDataLocationIndexed) {
                 RETURN_FALSE_INTERFACE
             }
         }
@@ -369,34 +369,34 @@ bool GrGLInterface::validate() const {
 
     // glGetStringi was added in version 3.0 of both desktop and ES.
     if (glVer >= GR_GL_VER(3, 0)) {
-        if (nullptr == fFunctions.fGetStringi) {
+        if (!fFunctions.fGetStringi) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     // glVertexAttribIPointer was added in version 3.0 of both desktop and ES.
     if (glVer >= GR_GL_VER(3, 0)) {
-        if (NULL == fFunctions.fVertexAttribIPointer) {
+        if (!fFunctions.fVertexAttribIPointer) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3,1)) {
-            if (nullptr == fFunctions.fTexBuffer) {
+            if (!fFunctions.fTexBuffer) {
                 RETURN_FALSE_INTERFACE;
             }
         }
         if (glVer >= GR_GL_VER(4,3)) {
-            if (nullptr == fFunctions.fTexBufferRange) {
+            if (!fFunctions.fTexBufferRange) {
                 RETURN_FALSE_INTERFACE;
             }
         }
     } else {
         if (glVer >= GR_GL_VER(3,2) || fExtensions.has("GL_OES_texture_buffer") ||
             fExtensions.has("GL_EXT_texture_buffer")) {
-            if (nullptr == fFunctions.fTexBuffer ||
-                nullptr == fFunctions.fTexBufferRange) {
+            if (!fFunctions.fTexBuffer ||
+                !fFunctions.fTexBufferRange) {
                 RETURN_FALSE_INTERFACE;
             }
         }
@@ -404,53 +404,53 @@ bool GrGLInterface::validate() const {
 
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3, 0) || fExtensions.has("GL_ARB_vertex_array_object")) {
-            if (nullptr == fFunctions.fBindVertexArray ||
-                nullptr == fFunctions.fDeleteVertexArrays ||
-                nullptr == fFunctions.fGenVertexArrays) {
+            if (!fFunctions.fBindVertexArray ||
+                !fFunctions.fDeleteVertexArrays ||
+                !fFunctions.fGenVertexArrays) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else {
         if (glVer >= GR_GL_VER(3,0) || fExtensions.has("GL_OES_vertex_array_object")) {
-            if (nullptr == fFunctions.fBindVertexArray ||
-                nullptr == fFunctions.fDeleteVertexArrays ||
-                nullptr == fFunctions.fGenVertexArrays) {
+            if (!fFunctions.fBindVertexArray ||
+                !fFunctions.fDeleteVertexArrays ||
+                !fFunctions.fGenVertexArrays) {
                 RETURN_FALSE_INTERFACE
             }
         }
     }
 
     if (fExtensions.has("GL_EXT_debug_marker")) {
-        if (nullptr == fFunctions.fInsertEventMarker ||
-            nullptr == fFunctions.fPushGroupMarker ||
-            nullptr == fFunctions.fPopGroupMarker) {
+        if (!fFunctions.fInsertEventMarker ||
+            !fFunctions.fPushGroupMarker ||
+            !fFunctions.fPopGroupMarker) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if ((kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,3)) ||
         fExtensions.has("GL_ARB_invalidate_subdata")) {
-        if (nullptr == fFunctions.fInvalidateBufferData ||
-            nullptr == fFunctions.fInvalidateBufferSubData ||
-            nullptr == fFunctions.fInvalidateFramebuffer ||
-            nullptr == fFunctions.fInvalidateSubFramebuffer ||
-            nullptr == fFunctions.fInvalidateTexImage ||
-            nullptr == fFunctions.fInvalidateTexSubImage) {
+        if (!fFunctions.fInvalidateBufferData ||
+            !fFunctions.fInvalidateBufferSubData ||
+            !fFunctions.fInvalidateFramebuffer ||
+            !fFunctions.fInvalidateSubFramebuffer ||
+            !fFunctions.fInvalidateTexImage ||
+            !fFunctions.fInvalidateTexSubImage) {
             RETURN_FALSE_INTERFACE;
         }
     } else if (kGLES_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,0)) {
         // ES 3.0 adds the framebuffer functions but not the others.
-        if (nullptr == fFunctions.fInvalidateFramebuffer ||
-            nullptr == fFunctions.fInvalidateSubFramebuffer) {
+        if (!fFunctions.fInvalidateFramebuffer ||
+            !fFunctions.fInvalidateSubFramebuffer) {
             RETURN_FALSE_INTERFACE;
         }
     }
 
     if (kGLES_GrGLStandard == fStandard && fExtensions.has("GL_CHROMIUM_map_sub")) {
-        if (nullptr == fFunctions.fMapBufferSubData ||
-            nullptr == fFunctions.fMapTexSubImage2D ||
-            nullptr == fFunctions.fUnmapBufferSubData ||
-            nullptr == fFunctions.fUnmapTexSubImage2D) {
+        if (!fFunctions.fMapBufferSubData ||
+            !fFunctions.fMapTexSubImage2D ||
+            !fFunctions.fUnmapBufferSubData ||
+            !fFunctions.fUnmapTexSubImage2D) {
             RETURN_FALSE_INTERFACE;
         }
     }
@@ -459,8 +459,8 @@ bool GrGLInterface::validate() const {
     if (glVer >= GR_GL_VER(3,0) ||
         (kGLES_GrGLStandard == fStandard && fExtensions.has("GL_EXT_map_buffer_range")) ||
         (kGL_GrGLStandard == fStandard && fExtensions.has("GL_ARB_map_buffer_range"))) {
-        if (nullptr == fFunctions.fMapBufferRange ||
-            nullptr == fFunctions.fFlushMappedBufferRange) {
+        if (!fFunctions.fMapBufferRange ||
+            !fFunctions.fFlushMappedBufferRange) {
             RETURN_FALSE_INTERFACE;
         }
     }
@@ -468,7 +468,7 @@ bool GrGLInterface::validate() const {
     if ((kGL_GrGLStandard == fStandard &&
          (glVer >= GR_GL_VER(3,2) || fExtensions.has("GL_ARB_texture_multisample"))) ||
         (kGLES_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,1))) {
-        if (NULL == fFunctions.fGetMultisamplefv) {
+        if (!fFunctions.fGetMultisamplefv) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -476,66 +476,66 @@ bool GrGLInterface::validate() const {
     if ((kGL_GrGLStandard == fStandard &&
          (glVer >= GR_GL_VER(4,3) || fExtensions.has("GL_ARB_program_interface_query"))) ||
         (kGLES_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,1))) {
-        if (nullptr == fFunctions.fGetProgramResourceLocation) {
+        if (!fFunctions.fGetProgramResourceLocation) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (kGLES_GrGLStandard == fStandard || glVer >= GR_GL_VER(4,1) ||
         fExtensions.has("GL_ARB_ES2_compatibility")) {
-        if (nullptr == fFunctions.fGetShaderPrecisionFormat) {
+        if (!fFunctions.fGetShaderPrecisionFormat) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (fExtensions.has("GL_NV_path_rendering") || fExtensions.has("GL_CHROMIUM_path_rendering")) {
-        if (nullptr == fFunctions.fMatrixLoadf ||
-            nullptr == fFunctions.fMatrixLoadIdentity ||
-            nullptr == fFunctions.fPathCommands ||
-            nullptr == fFunctions.fPathParameteri ||
-            nullptr == fFunctions.fPathParameterf ||
-            nullptr == fFunctions.fGenPaths ||
-            nullptr == fFunctions.fDeletePaths ||
-            nullptr == fFunctions.fIsPath ||
-            nullptr == fFunctions.fPathStencilFunc ||
-            nullptr == fFunctions.fStencilFillPath ||
-            nullptr == fFunctions.fStencilStrokePath ||
-            nullptr == fFunctions.fStencilFillPathInstanced ||
-            nullptr == fFunctions.fStencilStrokePathInstanced ||
-            nullptr == fFunctions.fCoverFillPath ||
-            nullptr == fFunctions.fCoverStrokePath ||
-            nullptr == fFunctions.fCoverFillPathInstanced ||
-            nullptr == fFunctions.fCoverStrokePathInstanced
+        if (!fFunctions.fMatrixLoadf ||
+            !fFunctions.fMatrixLoadIdentity ||
+            !fFunctions.fPathCommands ||
+            !fFunctions.fPathParameteri ||
+            !fFunctions.fPathParameterf ||
+            !fFunctions.fGenPaths ||
+            !fFunctions.fDeletePaths ||
+            !fFunctions.fIsPath ||
+            !fFunctions.fPathStencilFunc ||
+            !fFunctions.fStencilFillPath ||
+            !fFunctions.fStencilStrokePath ||
+            !fFunctions.fStencilFillPathInstanced ||
+            !fFunctions.fStencilStrokePathInstanced ||
+            !fFunctions.fCoverFillPath ||
+            !fFunctions.fCoverStrokePath ||
+            !fFunctions.fCoverFillPathInstanced ||
+            !fFunctions.fCoverStrokePathInstanced
 #if 0
             // List of functions that Skia uses, but which have been added since the initial release
             // of NV_path_rendering driver. We do not want to fail interface validation due to
             // missing features, we will just not use the extension.
             // Update this list -> update GrGLCaps::hasPathRenderingSupport too.
-            || nullptr == fFunctions.fStencilThenCoverFillPath ||
-            nullptr == fFunctions.fStencilThenCoverStrokePath ||
-            nullptr == fFunctions.fStencilThenCoverFillPathInstanced ||
-            nullptr == fFunctions.fStencilThenCoverStrokePathInstanced ||
-            nullptr == fFunctions.fProgramPathFragmentInputGen
+            || !fFunctions.fStencilThenCoverFillPath ||
+            !fFunctions.fStencilThenCoverStrokePath ||
+            !fFunctions.fStencilThenCoverFillPathInstanced ||
+            !fFunctions.fStencilThenCoverStrokePathInstanced ||
+            !fFunctions.fProgramPathFragmentInputGen
 #endif
             ) {
             RETURN_FALSE_INTERFACE
         }
         if (fExtensions.has("GL_CHROMIUM_path_rendering")) {
-            if (nullptr == fFunctions.fBindFragmentInputLocation) {
+            if (!fFunctions.fBindFragmentInputLocation) {
                 RETURN_FALSE_INTERFACE
             }
         }
     }
 
     if (fExtensions.has("GL_EXT_raster_multisample")) {
-        if (nullptr == fFunctions.fRasterSamples) {
+        if (!fFunctions.fRasterSamples) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (fExtensions.has("GL_NV_framebuffer_mixed_samples") ||
         fExtensions.has("GL_CHROMIUM_framebuffer_mixed_samples")) {
-        if (nullptr == fFunctions.fCoverageModulation) {
+        if (!fFunctions.fCoverageModulation) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -543,15 +543,15 @@ bool GrGLInterface::validate() const {
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3,1) ||
             fExtensions.has("GL_EXT_draw_instanced") || fExtensions.has("GL_ARB_draw_instanced")) {
-            if (nullptr == fFunctions.fDrawArraysInstanced ||
-                nullptr == fFunctions.fDrawElementsInstanced) {
+            if (!fFunctions.fDrawArraysInstanced ||
+                !fFunctions.fDrawElementsInstanced) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else if (kGLES_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3,0) || fExtensions.has("GL_EXT_draw_instanced")) {
-            if (nullptr == fFunctions.fDrawArraysInstanced ||
-                nullptr == fFunctions.fDrawElementsInstanced) {
+            if (!fFunctions.fDrawArraysInstanced ||
+                !fFunctions.fDrawElementsInstanced) {
                 RETURN_FALSE_INTERFACE
             }
         }
@@ -559,13 +559,13 @@ bool GrGLInterface::validate() const {
 
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3,2) || fExtensions.has("GL_ARB_instanced_arrays")) {
-            if (nullptr == fFunctions.fVertexAttribDivisor) {
+            if (!fFunctions.fVertexAttribDivisor) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else if (kGLES_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3,0) || fExtensions.has("GL_EXT_instanced_arrays")) {
-            if (nullptr == fFunctions.fVertexAttribDivisor) {
+            if (!fFunctions.fVertexAttribDivisor) {
                 RETURN_FALSE_INTERFACE
             }
         }
@@ -574,8 +574,8 @@ bool GrGLInterface::validate() const {
     if ((kGL_GrGLStandard == fStandard &&
          (glVer >= GR_GL_VER(4,0) || fExtensions.has("GL_ARB_draw_indirect"))) ||
         (kGLES_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,1))) {
-        if (NULL == fFunctions.fDrawArraysIndirect ||
-            NULL == fFunctions.fDrawElementsIndirect) {
+        if (!fFunctions.fDrawArraysIndirect ||
+            !fFunctions.fDrawElementsIndirect) {
             RETURN_FALSE_INTERFACE
         }
     }
@@ -583,142 +583,142 @@ bool GrGLInterface::validate() const {
     if ((kGL_GrGLStandard == fStandard &&
          (glVer >= GR_GL_VER(4,3) || fExtensions.has("GL_ARB_multi_draw_indirect"))) ||
         (kGLES_GrGLStandard == fStandard && fExtensions.has("GL_EXT_multi_draw_indirect"))) {
-        if (NULL == fFunctions.fMultiDrawArraysIndirect ||
-            NULL == fFunctions.fMultiDrawElementsIndirect) {
+        if (!fFunctions.fMultiDrawArraysIndirect ||
+            !fFunctions.fMultiDrawElementsIndirect) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (fExtensions.has("GL_NV_bindless_texture")) {
-        if (nullptr == fFunctions.fGetTextureHandle ||
-            nullptr == fFunctions.fGetTextureSamplerHandle ||
-            nullptr == fFunctions.fMakeTextureHandleResident ||
-            nullptr == fFunctions.fMakeTextureHandleNonResident ||
-            nullptr == fFunctions.fGetImageHandle ||
-            nullptr == fFunctions.fMakeImageHandleResident ||
-            nullptr == fFunctions.fMakeImageHandleNonResident ||
-            nullptr == fFunctions.fIsTextureHandleResident ||
-            nullptr == fFunctions.fIsImageHandleResident ||
-            nullptr == fFunctions.fUniformHandleui64 ||
-            nullptr == fFunctions.fUniformHandleui64v ||
-            nullptr == fFunctions.fProgramUniformHandleui64 ||
-            nullptr == fFunctions.fProgramUniformHandleui64v) {
+        if (!fFunctions.fGetTextureHandle ||
+            !fFunctions.fGetTextureSamplerHandle ||
+            !fFunctions.fMakeTextureHandleResident ||
+            !fFunctions.fMakeTextureHandleNonResident ||
+            !fFunctions.fGetImageHandle ||
+            !fFunctions.fMakeImageHandleResident ||
+            !fFunctions.fMakeImageHandleNonResident ||
+            !fFunctions.fIsTextureHandleResident ||
+            !fFunctions.fIsImageHandleResident ||
+            !fFunctions.fUniformHandleui64 ||
+            !fFunctions.fUniformHandleui64v ||
+            !fFunctions.fProgramUniformHandleui64 ||
+            !fFunctions.fProgramUniformHandleui64v) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (kGL_GrGLStandard == fStandard && fExtensions.has("GL_EXT_direct_state_access")) {
-        if (nullptr == fFunctions.fTextureParameteri ||
-            nullptr == fFunctions.fTextureParameteriv ||
-            nullptr == fFunctions.fTextureParameterf ||
-            nullptr == fFunctions.fTextureParameterfv ||
-            nullptr == fFunctions.fTextureImage1D ||
-            nullptr == fFunctions.fTextureImage2D ||
-            nullptr == fFunctions.fTextureSubImage1D ||
-            nullptr == fFunctions.fTextureSubImage2D ||
-            nullptr == fFunctions.fCopyTextureImage1D ||
-            nullptr == fFunctions.fCopyTextureImage2D ||
-            nullptr == fFunctions.fCopyTextureSubImage1D ||
-            nullptr == fFunctions.fCopyTextureSubImage2D ||
-            nullptr == fFunctions.fGetNamedBufferParameteriv ||
-            nullptr == fFunctions.fGetNamedBufferPointerv ||
-            nullptr == fFunctions.fGetNamedBufferSubData ||
-            nullptr == fFunctions.fGetTextureImage ||
-            nullptr == fFunctions.fGetTextureParameterfv ||
-            nullptr == fFunctions.fGetTextureParameteriv ||
-            nullptr == fFunctions.fGetTextureLevelParameterfv ||
-            nullptr == fFunctions.fGetTextureLevelParameteriv ||
-            nullptr == fFunctions.fMapNamedBuffer ||
-            nullptr == fFunctions.fNamedBufferData ||
-            nullptr == fFunctions.fNamedBufferSubData ||
-            nullptr == fFunctions.fProgramUniform1f ||
-            nullptr == fFunctions.fProgramUniform2f ||
-            nullptr == fFunctions.fProgramUniform3f ||
-            nullptr == fFunctions.fProgramUniform4f ||
-            nullptr == fFunctions.fProgramUniform1i ||
-            nullptr == fFunctions.fProgramUniform2i ||
-            nullptr == fFunctions.fProgramUniform3i ||
-            nullptr == fFunctions.fProgramUniform4i ||
-            nullptr == fFunctions.fProgramUniform1fv ||
-            nullptr == fFunctions.fProgramUniform2fv ||
-            nullptr == fFunctions.fProgramUniform3fv ||
-            nullptr == fFunctions.fProgramUniform4fv ||
-            nullptr == fFunctions.fProgramUniform1iv ||
-            nullptr == fFunctions.fProgramUniform2iv ||
-            nullptr == fFunctions.fProgramUniform3iv ||
-            nullptr == fFunctions.fProgramUniform4iv ||
-            nullptr == fFunctions.fProgramUniformMatrix2fv ||
-            nullptr == fFunctions.fProgramUniformMatrix3fv ||
-            nullptr == fFunctions.fProgramUniformMatrix4fv ||
-            nullptr == fFunctions.fUnmapNamedBuffer) {
+        if (!fFunctions.fTextureParameteri ||
+            !fFunctions.fTextureParameteriv ||
+            !fFunctions.fTextureParameterf ||
+            !fFunctions.fTextureParameterfv ||
+            !fFunctions.fTextureImage1D ||
+            !fFunctions.fTextureImage2D ||
+            !fFunctions.fTextureSubImage1D ||
+            !fFunctions.fTextureSubImage2D ||
+            !fFunctions.fCopyTextureImage1D ||
+            !fFunctions.fCopyTextureImage2D ||
+            !fFunctions.fCopyTextureSubImage1D ||
+            !fFunctions.fCopyTextureSubImage2D ||
+            !fFunctions.fGetNamedBufferParameteriv ||
+            !fFunctions.fGetNamedBufferPointerv ||
+            !fFunctions.fGetNamedBufferSubData ||
+            !fFunctions.fGetTextureImage ||
+            !fFunctions.fGetTextureParameterfv ||
+            !fFunctions.fGetTextureParameteriv ||
+            !fFunctions.fGetTextureLevelParameterfv ||
+            !fFunctions.fGetTextureLevelParameteriv ||
+            !fFunctions.fMapNamedBuffer ||
+            !fFunctions.fNamedBufferData ||
+            !fFunctions.fNamedBufferSubData ||
+            !fFunctions.fProgramUniform1f ||
+            !fFunctions.fProgramUniform2f ||
+            !fFunctions.fProgramUniform3f ||
+            !fFunctions.fProgramUniform4f ||
+            !fFunctions.fProgramUniform1i ||
+            !fFunctions.fProgramUniform2i ||
+            !fFunctions.fProgramUniform3i ||
+            !fFunctions.fProgramUniform4i ||
+            !fFunctions.fProgramUniform1fv ||
+            !fFunctions.fProgramUniform2fv ||
+            !fFunctions.fProgramUniform3fv ||
+            !fFunctions.fProgramUniform4fv ||
+            !fFunctions.fProgramUniform1iv ||
+            !fFunctions.fProgramUniform2iv ||
+            !fFunctions.fProgramUniform3iv ||
+            !fFunctions.fProgramUniform4iv ||
+            !fFunctions.fProgramUniformMatrix2fv ||
+            !fFunctions.fProgramUniformMatrix3fv ||
+            !fFunctions.fProgramUniformMatrix4fv ||
+            !fFunctions.fUnmapNamedBuffer) {
             RETURN_FALSE_INTERFACE
         }
         if (glVer >= GR_GL_VER(1,2)) {
-            if (nullptr == fFunctions.fTextureImage3D ||
-                nullptr == fFunctions.fTextureSubImage3D ||
-                nullptr == fFunctions.fCopyTextureSubImage3D ||
-                nullptr == fFunctions.fCompressedTextureImage3D ||
-                nullptr == fFunctions.fCompressedTextureImage2D ||
-                nullptr == fFunctions.fCompressedTextureImage1D ||
-                nullptr == fFunctions.fCompressedTextureSubImage3D ||
-                nullptr == fFunctions.fCompressedTextureSubImage2D ||
-                nullptr == fFunctions.fCompressedTextureSubImage1D ||
-                nullptr == fFunctions.fGetCompressedTextureImage) {
+            if (!fFunctions.fTextureImage3D ||
+                !fFunctions.fTextureSubImage3D ||
+                !fFunctions.fCopyTextureSubImage3D ||
+                !fFunctions.fCompressedTextureImage3D ||
+                !fFunctions.fCompressedTextureImage2D ||
+                !fFunctions.fCompressedTextureImage1D ||
+                !fFunctions.fCompressedTextureSubImage3D ||
+                !fFunctions.fCompressedTextureSubImage2D ||
+                !fFunctions.fCompressedTextureSubImage1D ||
+                !fFunctions.fGetCompressedTextureImage) {
                 RETURN_FALSE_INTERFACE
             }
         }
         if (glVer >= GR_GL_VER(2,1)) {
-            if (nullptr == fFunctions.fProgramUniformMatrix2x3fv ||
-                nullptr == fFunctions.fProgramUniformMatrix3x2fv ||
-                nullptr == fFunctions.fProgramUniformMatrix2x4fv ||
-                nullptr == fFunctions.fProgramUniformMatrix4x2fv ||
-                nullptr == fFunctions.fProgramUniformMatrix3x4fv ||
-                nullptr == fFunctions.fProgramUniformMatrix4x3fv) {
+            if (!fFunctions.fProgramUniformMatrix2x3fv ||
+                !fFunctions.fProgramUniformMatrix3x2fv ||
+                !fFunctions.fProgramUniformMatrix2x4fv ||
+                !fFunctions.fProgramUniformMatrix4x2fv ||
+                !fFunctions.fProgramUniformMatrix3x4fv ||
+                !fFunctions.fProgramUniformMatrix4x3fv) {
                 RETURN_FALSE_INTERFACE
             }
         }
         if (glVer >= GR_GL_VER(3,0)) {
-            if (nullptr == fFunctions.fNamedRenderbufferStorage ||
-                nullptr == fFunctions.fGetNamedRenderbufferParameteriv ||
-                nullptr == fFunctions.fNamedRenderbufferStorageMultisample ||
-                nullptr == fFunctions.fCheckNamedFramebufferStatus ||
-                nullptr == fFunctions.fNamedFramebufferTexture1D ||
-                nullptr == fFunctions.fNamedFramebufferTexture2D ||
-                nullptr == fFunctions.fNamedFramebufferTexture3D ||
-                nullptr == fFunctions.fNamedFramebufferRenderbuffer ||
-                nullptr == fFunctions.fGetNamedFramebufferAttachmentParameteriv ||
-                nullptr == fFunctions.fGenerateTextureMipmap ||
-                nullptr == fFunctions.fFramebufferDrawBuffer ||
-                nullptr == fFunctions.fFramebufferDrawBuffers ||
-                nullptr == fFunctions.fFramebufferReadBuffer ||
-                nullptr == fFunctions.fGetFramebufferParameteriv ||
-                nullptr == fFunctions.fNamedCopyBufferSubData ||
-                nullptr == fFunctions.fVertexArrayVertexOffset ||
-                nullptr == fFunctions.fVertexArrayColorOffset ||
-                nullptr == fFunctions.fVertexArrayEdgeFlagOffset ||
-                nullptr == fFunctions.fVertexArrayIndexOffset ||
-                nullptr == fFunctions.fVertexArrayNormalOffset ||
-                nullptr == fFunctions.fVertexArrayTexCoordOffset ||
-                nullptr == fFunctions.fVertexArrayMultiTexCoordOffset ||
-                nullptr == fFunctions.fVertexArrayFogCoordOffset ||
-                nullptr == fFunctions.fVertexArraySecondaryColorOffset ||
-                nullptr == fFunctions.fVertexArrayVertexAttribOffset ||
-                nullptr == fFunctions.fVertexArrayVertexAttribIOffset ||
-                nullptr == fFunctions.fEnableVertexArray ||
-                nullptr == fFunctions.fDisableVertexArray ||
-                nullptr == fFunctions.fEnableVertexArrayAttrib ||
-                nullptr == fFunctions.fDisableVertexArrayAttrib ||
-                nullptr == fFunctions.fGetVertexArrayIntegerv ||
-                nullptr == fFunctions.fGetVertexArrayPointerv ||
-                nullptr == fFunctions.fGetVertexArrayIntegeri_v ||
-                nullptr == fFunctions.fGetVertexArrayPointeri_v ||
-                nullptr == fFunctions.fMapNamedBufferRange ||
-                nullptr == fFunctions.fFlushMappedNamedBufferRange) {
+            if (!fFunctions.fNamedRenderbufferStorage ||
+                !fFunctions.fGetNamedRenderbufferParameteriv ||
+                !fFunctions.fNamedRenderbufferStorageMultisample ||
+                !fFunctions.fCheckNamedFramebufferStatus ||
+                !fFunctions.fNamedFramebufferTexture1D ||
+                !fFunctions.fNamedFramebufferTexture2D ||
+                !fFunctions.fNamedFramebufferTexture3D ||
+                !fFunctions.fNamedFramebufferRenderbuffer ||
+                !fFunctions.fGetNamedFramebufferAttachmentParameteriv ||
+                !fFunctions.fGenerateTextureMipmap ||
+                !fFunctions.fFramebufferDrawBuffer ||
+                !fFunctions.fFramebufferDrawBuffers ||
+                !fFunctions.fFramebufferReadBuffer ||
+                !fFunctions.fGetFramebufferParameteriv ||
+                !fFunctions.fNamedCopyBufferSubData ||
+                !fFunctions.fVertexArrayVertexOffset ||
+                !fFunctions.fVertexArrayColorOffset ||
+                !fFunctions.fVertexArrayEdgeFlagOffset ||
+                !fFunctions.fVertexArrayIndexOffset ||
+                !fFunctions.fVertexArrayNormalOffset ||
+                !fFunctions.fVertexArrayTexCoordOffset ||
+                !fFunctions.fVertexArrayMultiTexCoordOffset ||
+                !fFunctions.fVertexArrayFogCoordOffset ||
+                !fFunctions.fVertexArraySecondaryColorOffset ||
+                !fFunctions.fVertexArrayVertexAttribOffset ||
+                !fFunctions.fVertexArrayVertexAttribIOffset ||
+                !fFunctions.fEnableVertexArray ||
+                !fFunctions.fDisableVertexArray ||
+                !fFunctions.fEnableVertexArrayAttrib ||
+                !fFunctions.fDisableVertexArrayAttrib ||
+                !fFunctions.fGetVertexArrayIntegerv ||
+                !fFunctions.fGetVertexArrayPointerv ||
+                !fFunctions.fGetVertexArrayIntegeri_v ||
+                !fFunctions.fGetVertexArrayPointeri_v ||
+                !fFunctions.fMapNamedBufferRange ||
+                !fFunctions.fFlushMappedNamedBufferRange) {
                 RETURN_FALSE_INTERFACE
             }
         }
         if (glVer >= GR_GL_VER(3,1)) {
-            if (nullptr == fFunctions.fTextureBuffer) {
+            if (!fFunctions.fTextureBuffer) {
                 RETURN_FALSE_INTERFACE;
             }
         }
@@ -726,88 +726,88 @@ bool GrGLInterface::validate() const {
 
     if ((kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,3)) ||
         fExtensions.has("GL_KHR_debug")) {
-        if (nullptr == fFunctions.fDebugMessageControl ||
-            nullptr == fFunctions.fDebugMessageInsert ||
-            nullptr == fFunctions.fDebugMessageCallback ||
-            nullptr == fFunctions.fGetDebugMessageLog ||
-            nullptr == fFunctions.fPushDebugGroup ||
-            nullptr == fFunctions.fPopDebugGroup ||
-            nullptr == fFunctions.fObjectLabel) {
+        if (!fFunctions.fDebugMessageControl ||
+            !fFunctions.fDebugMessageInsert ||
+            !fFunctions.fDebugMessageCallback ||
+            !fFunctions.fGetDebugMessageLog ||
+            !fFunctions.fPushDebugGroup ||
+            !fFunctions.fPopDebugGroup ||
+            !fFunctions.fObjectLabel) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (fExtensions.has("GL_EXT_window_rectangles")) {
-        if (nullptr == fFunctions.fWindowRectangles) {
+        if (!fFunctions.fWindowRectangles) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if ((kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,0)) ||
         fExtensions.has("GL_ARB_sample_shading")) {
-        if (nullptr == fFunctions.fMinSampleShading) {
+        if (!fFunctions.fMinSampleShading) {
             RETURN_FALSE_INTERFACE
         }
     } else if (kGLES_GrGLStandard == fStandard && fExtensions.has("GL_OES_sample_shading")) {
-        if (nullptr == fFunctions.fMinSampleShading) {
+        if (!fFunctions.fMinSampleShading) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3, 2) || fExtensions.has("GL_ARB_sync")) {
-            if (nullptr == fFunctions.fFenceSync ||
+            if (!fFunctions.fFenceSync ||
                 // Is sync needs to be added to chrome before uncommenting
-                // nullptr == fFunctions.fIsSync ||
-                nullptr == fFunctions.fClientWaitSync ||
-                nullptr == fFunctions.fWaitSync ||
-                nullptr == fFunctions.fDeleteSync) {
+                // !fFunctions.fIsSync ||
+                !fFunctions.fClientWaitSync ||
+                !fFunctions.fWaitSync ||
+                !fFunctions.fDeleteSync) {
                 RETURN_FALSE_INTERFACE
             }
         }
     } else if (kGLES_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(3, 0) || fExtensions.has("GL_APPLE_sync")) {
-            if (nullptr == fFunctions.fFenceSync ||
+            if (!fFunctions.fFenceSync ||
                 // Is sync needs to be added to chrome before uncommenting
-                // nullptr == fFunctions.fIsSync ||
-                nullptr == fFunctions.fClientWaitSync ||
-                nullptr == fFunctions.fWaitSync ||
-                nullptr == fFunctions.fDeleteSync) {
+                // !fFunctions.fIsSync ||
+                !fFunctions.fClientWaitSync ||
+                !fFunctions.fWaitSync ||
+                !fFunctions.fDeleteSync) {
                 RETURN_FALSE_INTERFACE
             }
         }
     }
 
     if (fExtensions.has("EGL_KHR_image") || fExtensions.has("EGL_KHR_image_base")) {
-        if (nullptr == fFunctions.fEGLCreateImage ||
-            nullptr == fFunctions.fEGLDestroyImage) {
+        if (!fFunctions.fEGLCreateImage ||
+            !fFunctions.fEGLDestroyImage) {
             RETURN_FALSE_INTERFACE
         }
     }
 
     // glDrawRangeElements was added to ES in 3.0.
     if (kGL_GrGLStandard == fStandard || glVer >= GR_GL_VER(3,0)) {
-        if (nullptr == fFunctions.fDrawRangeElements) {
+        if (!fFunctions.fDrawRangeElements) {
             RETURN_FALSE_INTERFACE;
         }
     }
 
     if (kGL_GrGLStandard == fStandard) {
         if (glVer >= GR_GL_VER(4,2) || fExtensions.has("GL_ARB_shader_image_load_store")) {
-            if (nullptr == fFunctions.fBindImageTexture ||
-                nullptr == fFunctions.fMemoryBarrier) {
+            if (!fFunctions.fBindImageTexture ||
+                !fFunctions.fMemoryBarrier) {
                 RETURN_FALSE_INTERFACE;
             }
         }
         if (glVer >= GR_GL_VER(4,5) || fExtensions.has("GL_ARB_ES3_1_compatibility")) {
-            if (nullptr == fFunctions.fMemoryBarrierByRegion) {
+            if (!fFunctions.fMemoryBarrierByRegion) {
                 RETURN_FALSE_INTERFACE;
             }
         }
     } else if (kGLES_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,1)) {
-        if (nullptr == fFunctions.fBindImageTexture ||
-            nullptr == fFunctions.fMemoryBarrier ||
-            nullptr == fFunctions.fMemoryBarrierByRegion) {
+        if (!fFunctions.fBindImageTexture ||
+            !fFunctions.fMemoryBarrier ||
+            !fFunctions.fMemoryBarrierByRegion) {
             RETURN_FALSE_INTERFACE;
         }
     }
@@ -816,7 +816,7 @@ bool GrGLInterface::validate() const {
     if ((kGL_GrGLStandard == fStandard &&
          (glVer >= GR_GL_VER(4,2) || fExtensions.has("GL_ARB_internalformat_query"))) ||
         (kGLES_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,0))) {
-        if (nullptr == fFunctions.fGetInternalformativ) {
+        if (!fFunctions.fGetInternalformativ) {
         //    RETURN_FALSE_INTERFACE;
         }
     }