Style Change: NULL->nullptr

src/gpu/gl/egl/SkCreatePlatformGLContext_egl.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gl/SkGLContext.h"
 
 #include <GLES2/gl2.h>
@@ skipping 75 matching lines @@
     size_t api = 0;
     if (forcedGpuAPI == kGL_GrGLStandard) {
         apiLimit = 1;
     } else if (forcedGpuAPI == kGLES_GrGLStandard) {
         api = 1;
     }
     SkASSERT(forcedGpuAPI == kNone_GrGLStandard || kAPIs[api].fStandard == forcedGpuAPI);
 
     SkAutoTUnref<const GrGLInterface> gl;
 
-    for (; NULL == gl.get() && api < apiLimit; ++api) {
+    for (; nullptr == gl.get() && api < apiLimit; ++api) {
         fDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 
         EGLint majorVersion;
         EGLint minorVersion;
         eglInitialize(fDisplay, &majorVersion, &minorVersion);
 
 #if 0
         SkDebugf("VENDOR: %s\n", eglQueryString(fDisplay, EGL_VENDOR));
         SkDebugf("APIS: %s\n", eglQueryString(fDisplay, EGL_CLIENT_APIS));
         SkDebugf("VERSION: %s\n", eglQueryString(fDisplay, EGL_VERSION));
@@ skipping 19 matching lines @@
         if (!eglChooseConfig(fDisplay, configAttribs, &surfaceConfig, 1, &numConfigs)) {
             SkDebugf("eglChooseConfig failed. EGL Error: 0x%08x\n", eglGetError());
             continue;
         }
 
         if (0 == numConfigs) {
             SkDebugf("No suitable EGL config found.\n");
             continue;
         }
 
-        fContext = eglCreateContext(fDisplay, surfaceConfig, NULL, kAPIs[api].fContextAttribs);
+        fContext = eglCreateContext(fDisplay, surfaceConfig, nullptr, kAPIs[api].fContextAttribs);
         if (EGL_NO_CONTEXT == fContext) {
             SkDebugf("eglCreateContext failed.  EGL Error: 0x%08x\n", eglGetError());
             continue;
         }
 
         static const EGLint kSurfaceAttribs[] = {
             EGL_WIDTH, 1,
             EGL_HEIGHT, 1,
             EGL_NONE
         };
 
         fSurface = eglCreatePbufferSurface(fDisplay, surfaceConfig, kSurfaceAttribs);
         if (EGL_NO_SURFACE == fSurface) {
             SkDebugf("eglCreatePbufferSurface failed. EGL Error: 0x%08x\n", eglGetError());
             this->destroyGLContext();
             continue;
         }
 
         if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
             SkDebugf("eglMakeCurrent failed.  EGL Error: 0x%08x\n", eglGetError());
             this->destroyGLContext();
             continue;
         }
 
         gl.reset(GrGLCreateNativeInterface());
-        if (NULL == gl.get()) {
+        if (nullptr == gl.get()) {
             SkDebugf("Failed to create gl interface.\n");
             this->destroyGLContext();
             continue;
         }
 
         if (!gl->validate()) {
             SkDebugf("Failed to validate gl interface.\n");
             this->destroyGLContext();
             continue;
         }
@@ skipping 54 matching lines @@
             (match[extensionLength] == ' ' || match[extensionLength] == '\0')) {
             return true;
         }
         extensionsStr = match + extensionLength;
     }
     return false;
 }
 
 SkEGLFenceSync* SkEGLFenceSync::CreateIfSupported(EGLDisplay display) {
     if (!display || !supports_egl_extension(display, "EGL_KHR_fence_sync")) {
-        return NULL;
+        return nullptr;
     }
     return new SkEGLFenceSync(display);
 }
 
 SkPlatformGpuFence SkEGLFenceSync::insertFence() const {
-    return eglCreateSyncKHR(fDisplay, EGL_SYNC_FENCE_KHR, NULL);
+    return eglCreateSyncKHR(fDisplay, EGL_SYNC_FENCE_KHR, nullptr);
 }
 
 bool SkEGLFenceSync::flushAndWaitFence(SkPlatformGpuFence platformFence) const {
     EGLSyncKHR eglsync = static_cast<EGLSyncKHR>(platformFence);
     return EGL_CONDITION_SATISFIED_KHR == eglClientWaitSyncKHR(fDisplay,
                                                                eglsync,
                                                                EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                                                                EGL_FOREVER_KHR);
 }
 
 void SkEGLFenceSync::deleteFence(SkPlatformGpuFence platformFence) const {
     EGLSyncKHR eglsync = static_cast<EGLSyncKHR>(platformFence);
     eglDestroySyncKHR(fDisplay, eglsync);
 }
 
 } // anonymous namespace
 
 SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI) {
     EGLGLContext* ctx = new EGLGLContext(forcedGpuAPI);
     if (!ctx->isValid()) {
         delete ctx;
-        return NULL;
+        return nullptr;
     }
     return ctx;
 }