Style Change: NULL->nullptr

src/gpu/gl/SkGLContext.cpp

 
 /*
  * Copyright 2013 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 "GrGLUtil.h"
 #include "SkGpuFenceSync.h"
@@ skipping 31 matching lines @@
     memset(fFrameFences, 0, sizeof(fFrameFences));
 }
 
 SkGLContext::~SkGLContext() {
     // Subclass should call teardown.
 #ifdef SK_DEBUG
     for (size_t i = 0; i < SK_ARRAY_COUNT(fFrameFences); i++) {
         SkASSERT(0 == fFrameFences[i]);
     }
 #endif
-    SkASSERT(NULL == fGL.get());
-    SkASSERT(NULL == fFenceSync.get());
+    SkASSERT(nullptr == fGL.get());
+    SkASSERT(nullptr == fFenceSync.get());
 }
 
 void SkGLContext::init(const GrGLInterface* gl, SkGpuFenceSync* fenceSync) {
     SkASSERT(!fGL.get());
     fGL.reset(gl);
     fFenceSync.reset(fenceSync ? fenceSync : GLFenceSync::CreateIfSupported(this));
 }
 
 void SkGLContext::teardown() {
     if (fFenceSync) {
         for (size_t i = 0; i < SK_ARRAY_COUNT(fFrameFences); i++) {
             if (fFrameFences[i]) {
                 fFenceSync->deleteFence(fFrameFences[i]);
                 fFrameFences[i] = 0;
             }
         }
-        fFenceSync.reset(NULL);
+        fFenceSync.reset(nullptr);
     }
 
-    fGL.reset(NULL);
+    fGL.reset(nullptr);
 }
 
 void SkGLContext::makeCurrent() const {
     this->onPlatformMakeCurrent();
 }
 
 void SkGLContext::swapBuffers() {
     if (!fFenceSync) {
         // Fallback on the platform SwapBuffers method for synchronization. This may have no effect.
         this->onPlatformSwapBuffers();
@@ skipping 21 matching lines @@
 }
 
 SkGLContext::GLFenceSync* SkGLContext::GLFenceSync::CreateIfSupported(const SkGLContext* ctx) {
     SkAutoTDelete<GLFenceSync> ret(new GLFenceSync);
 
     if (kGL_GrGLStandard == ctx->gl()->fStandard) {
         const GrGLubyte* versionStr;
         SK_GL_RET(*ctx, versionStr, GetString(GR_GL_VERSION));
         GrGLVersion version = GrGLGetVersionFromString(reinterpret_cast<const char*>(versionStr));
         if (version < GR_GL_VER(3,2) && !ctx->gl()->hasExtension("GL_ARB_sync")) {
-            return NULL;
+            return nullptr;
         }
         ret->fGLFenceSync = reinterpret_cast<GLFenceSyncProc>(
             ctx->onPlatformGetProcAddress("glFenceSync"));
         ret->fGLClientWaitSync = reinterpret_cast<GLClientWaitSyncProc>(
             ctx->onPlatformGetProcAddress("glClientWaitSync"));
         ret->fGLDeleteSync = reinterpret_cast<GLDeleteSyncProc>(
             ctx->onPlatformGetProcAddress("glDeleteSync"));
     } else {
         if (!ctx->gl()->hasExtension("GL_APPLE_sync")) {
-            return NULL;
+            return nullptr;
         }
         ret->fGLFenceSync = reinterpret_cast<GLFenceSyncProc>(
             ctx->onPlatformGetProcAddress("glFenceSyncAPPLE"));
         ret->fGLClientWaitSync = reinterpret_cast<GLClientWaitSyncProc>(
             ctx->onPlatformGetProcAddress("glClientWaitSyncAPPLE"));
         ret->fGLDeleteSync = reinterpret_cast<GLDeleteSyncProc>(
             ctx->onPlatformGetProcAddress("glDeleteSyncAPPLE"));
     }
 
     if (!ret->fGLFenceSync || !ret->fGLClientWaitSync || !ret->fGLDeleteSync) {
-        return NULL;
+        return nullptr;
     }
 
     return ret.detach();
 }
 
 SkPlatformGpuFence SkGLContext::GLFenceSync::insertFence() const {
     return fGLFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
 }
 
 bool SkGLContext::GLFenceSync::flushAndWaitFence(SkPlatformGpuFence fence) const {
     GLsync glsync = static_cast<GLsync>(fence);
     return GL_WAIT_FAILED != fGLClientWaitSync(glsync, GL_SYNC_FLUSH_COMMANDS_BIT, -1);
 }
 
 void SkGLContext::GLFenceSync::deleteFence(SkPlatformGpuFence fence) const {
     GLsync glsync = static_cast<GLsync>(fence);
     fGLDeleteSync(glsync);
 }