Style Change: NULL->nullptr

src/utils/win/SkWGL_win.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 "SkWGL.h"
 
 #include "SkTDArray.h"
 #include "SkTSearch.h"
 #include "SkTSort.h"
 
 bool SkWGLExtensions::hasExtension(HDC dc, const char* ext) const {
-    if (NULL == this->fGetExtensionsString) {
+    if (nullptr == this->fGetExtensionsString) {
         return false;
     }
     if (!strcmp("WGL_ARB_extensions_string", ext)) {
         return true;
     }
     const char* extensionString = this->getExtensionsString(dc);
     size_t extLength = strlen(ext);
 
     while (true) {
         size_t n = strcspn(extensionString, " ");
@@ skipping 134 matching lines @@
 
 #if defined(UNICODE)
     #define STR_LIT(X) L## #X
 #else
     #define STR_LIT(X) #X
 #endif
 
 #define DUMMY_CLASS STR_LIT("DummyClass")
 
 HWND create_dummy_window() {
-    HMODULE module = GetModuleHandle(NULL);
+    HMODULE module = GetModuleHandle(nullptr);
     HWND dummy;
     RECT windowRect;
     windowRect.left = 0;
     windowRect.right = 8;
     windowRect.top = 0;
     windowRect.bottom = 8;
 
     WNDCLASS wc;
 
     wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
     wc.lpfnWndProc = (WNDPROC) DefWindowProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = module;
-    wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
-    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-    wc.hbrBackground = NULL;
-    wc.lpszMenuName = NULL;
+    wc.hIcon = LoadIcon(nullptr, IDI_WINLOGO);
+    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    wc.hbrBackground = nullptr;
+    wc.lpszMenuName = nullptr;
     wc.lpszClassName = DUMMY_CLASS;
 
     if(!RegisterClass(&wc)) {
         return 0;
     }
 
     DWORD style, exStyle;
     exStyle = WS_EX_CLIENTEDGE;
     style = WS_SYSMENU;
 
     AdjustWindowRectEx(&windowRect, style, false, exStyle);
     if(!(dummy = CreateWindowEx(exStyle,
                                 DUMMY_CLASS,
                                 STR_LIT("DummyWindow"),
                                 WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style,
                                 0, 0,
                                 windowRect.right-windowRect.left,
                                 windowRect.bottom-windowRect.top,
-                                NULL, NULL,
+                                nullptr, nullptr,
                                 module,
-                                NULL))) {
+                                nullptr))) {
         UnregisterClass(DUMMY_CLASS, module);
-        return NULL;
+        return nullptr;
     }
     ShowWindow(dummy, SW_HIDE);
 
     return dummy;
 }
 
 void destroy_dummy_window(HWND dummy) {
     DestroyWindow(dummy);
-    HMODULE module = GetModuleHandle(NULL);
+    HMODULE module = GetModuleHandle(nullptr);
     UnregisterClass(DUMMY_CLASS, module);
 }
 }
 
 #define GET_PROC(NAME, SUFFIX) f##NAME = \
                      (##NAME##Proc) wglGetProcAddress("wgl" #NAME #SUFFIX)
 
 SkWGLExtensions::SkWGLExtensions()
-    : fGetExtensionsString(NULL)
-    , fChoosePixelFormat(NULL)
-    , fGetPixelFormatAttribfv(NULL)
-    , fGetPixelFormatAttribiv(NULL)
-    , fCreateContextAttribs(NULL)
-    , fSwapInterval(NULL)
-    , fCreatePbuffer(NULL)
-    , fGetPbufferDC(NULL)
-    , fReleasePbufferDC(NULL)
-    , fDestroyPbuffer(NULL)
+    : fGetExtensionsString(nullptr)
+    , fChoosePixelFormat(nullptr)
+    , fGetPixelFormatAttribfv(nullptr)
+    , fGetPixelFormatAttribiv(nullptr)
+    , fCreateContextAttribs(nullptr)
+    , fSwapInterval(nullptr)
+    , fCreatePbuffer(nullptr)
+    , fGetPbufferDC(nullptr)
+    , fReleasePbufferDC(nullptr)
+    , fDestroyPbuffer(nullptr)
  {
     HDC prevDC = wglGetCurrentDC();
     HGLRC prevGLRC = wglGetCurrentContext();
 
     PIXELFORMATDESCRIPTOR dummyPFD;
 
     ZeroMemory(&dummyPFD, sizeof(dummyPFD));
     dummyPFD.nSize = sizeof(dummyPFD);
     dummyPFD.nVersion = 1;
     dummyPFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
@@ skipping 15 matching lines @@
         GET_PROC(ChoosePixelFormat, ARB);
         GET_PROC(GetPixelFormatAttribiv, ARB);
         GET_PROC(GetPixelFormatAttribfv, ARB);
         GET_PROC(CreateContextAttribs, ARB);
         GET_PROC(SwapInterval, EXT);
         GET_PROC(CreatePbuffer, ARB);
         GET_PROC(GetPbufferDC, ARB);
         GET_PROC(ReleasePbufferDC, ARB);
         GET_PROC(DestroyPbuffer, ARB);
 
-        wglMakeCurrent(dummyDC, NULL);
+        wglMakeCurrent(dummyDC, nullptr);
         wglDeleteContext(dummyGLRC);
         destroy_dummy_window(dummyWND);
     }
 
     wglMakeCurrent(prevDC, prevGLRC);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void get_pixel_formats_to_try(HDC dc, const SkWGLExtensions& extensions,
@@ skipping 36 matching lines @@
     // Get a non-MSAA format
     int* format = -1 == formatsToTry[0] ? &formatsToTry[0] : &formatsToTry[1];
     unsigned int num;
     extensions.choosePixelFormat(dc, iAttrs, fAttrs, 1, format, &num);
 }
 
 static HGLRC create_gl_context(HDC dc, SkWGLExtensions extensions, SkWGLContextRequest contextType) {
     HDC prevDC = wglGetCurrentDC();
     HGLRC prevGLRC = wglGetCurrentContext();
 
-    HGLRC glrc = NULL;
+    HGLRC glrc = nullptr;
     if (kGLES_SkWGLContextRequest == contextType) {
         if (!extensions.hasExtension(dc, "WGL_EXT_create_context_es2_profile")) {
             wglMakeCurrent(prevDC, prevGLRC);
-            return NULL;
+            return nullptr;
         }
         static const int glesAttribs[] = {
             SK_WGL_CONTEXT_MAJOR_VERSION, 3,
             SK_WGL_CONTEXT_MINOR_VERSION, 0,
             SK_WGL_CONTEXT_PROFILE_MASK,  SK_WGL_CONTEXT_ES2_PROFILE_BIT,
             0,
         };
-        glrc = extensions.createContextAttribs(dc, NULL, glesAttribs);
-        if (NULL == glrc) {
+        glrc = extensions.createContextAttribs(dc, nullptr, glesAttribs);
+        if (nullptr == glrc) {
             wglMakeCurrent(prevDC, prevGLRC);
-            return NULL;
+            return nullptr;
         }
     } else {
         if (kGLPreferCoreProfile_SkWGLContextRequest == contextType &&
             extensions.hasExtension(dc, "WGL_ARB_create_context")) {
             static const int kCoreGLVersions[] = {
                 4, 3,
                 4, 2,
                 4, 1,
                 4, 0,
                 3, 3,
                 3, 2,
             };
             int coreProfileAttribs[] = {
                 SK_WGL_CONTEXT_MAJOR_VERSION, -1,
                 SK_WGL_CONTEXT_MINOR_VERSION, -1,
                 SK_WGL_CONTEXT_PROFILE_MASK,  SK_WGL_CONTEXT_CORE_PROFILE_BIT,
                 0,
             };
             for (int v = 0; v < SK_ARRAY_COUNT(kCoreGLVersions) / 2; ++v) {
                 coreProfileAttribs[1] = kCoreGLVersions[2 * v];
                 coreProfileAttribs[3] = kCoreGLVersions[2 * v + 1];
-                glrc = extensions.createContextAttribs(dc, NULL, coreProfileAttribs);
+                glrc = extensions.createContextAttribs(dc, nullptr, coreProfileAttribs);
                 if (glrc) {
                     break;
                 }
             }
         }
     }
 
-    if (NULL == glrc) {
+    if (nullptr == glrc) {
         glrc = wglCreateContext(dc);
     }
     SkASSERT(glrc);
 
     wglMakeCurrent(prevDC, prevGLRC);
 
     // This might help make the context non-vsynced.
     if (extensions.hasExtension(dc, "WGL_EXT_swap_control")) {
         extensions.swapInterval(-1);
     }
     return glrc;
 }
 
 HGLRC SkCreateWGLContext(HDC dc, int msaaSampleCount, SkWGLContextRequest contextType) {
     SkWGLExtensions extensions;
     if (!extensions.hasExtension(dc, "WGL_ARB_pixel_format")) {
-        return NULL;
+        return nullptr;
     }
 
     BOOL set = FALSE;
 
     int pixelFormatsToTry[] = { -1, -1 };
     get_pixel_formats_to_try(dc, extensions, true, msaaSampleCount, pixelFormatsToTry);
     for (int f = 0;
          !set && -1 != pixelFormatsToTry[f] && f < SK_ARRAY_COUNT(pixelFormatsToTry);
          ++f) {
         PIXELFORMATDESCRIPTOR pfd;
         DescribePixelFormat(dc, pixelFormatsToTry[f], sizeof(pfd), &pfd);
         set = SetPixelFormat(dc, pixelFormatsToTry[f], &pfd);
     }
 
     if (!set) {
-        return NULL;
+        return nullptr;
     }
 
     return create_gl_context(dc, extensions, contextType);}
 
 SkWGLPbufferContext* SkWGLPbufferContext::Create(HDC parentDC, int msaaSampleCount,
                                                  SkWGLContextRequest contextType) {
     SkWGLExtensions extensions;
     if (!extensions.hasExtension(parentDC, "WGL_ARB_pixel_format") ||
         !extensions.hasExtension(parentDC, "WGL_ARB_pbuffer")) {
-        return NULL;
+        return nullptr;
     }
 
     // try for single buffer first
     for (int dblBuffer = 0; dblBuffer < 2; ++dblBuffer) {
         int pixelFormatsToTry[] = { -1, -1 };
         get_pixel_formats_to_try(parentDC, extensions, (0 != dblBuffer), msaaSampleCount,
                                  pixelFormatsToTry);
         for (int f = 0; -1 != pixelFormatsToTry[f] && f < SK_ARRAY_COUNT(pixelFormatsToTry); ++f) {
-            HPBUFFER pbuf = extensions.createPbuffer(parentDC, pixelFormatsToTry[f], 1, 1, NULL);
+            HPBUFFER pbuf = extensions.createPbuffer(parentDC, pixelFormatsToTry[f], 1, 1, nullptr);
             if (0 != pbuf) {
                 HDC dc = extensions.getPbufferDC(pbuf);
                 if (dc) {
                     HGLRC glrc = create_gl_context(dc, extensions, contextType);
                     if (glrc) {
                         return new SkWGLPbufferContext(pbuf, dc, glrc);
                     }
                     extensions.releasePbufferDC(pbuf, dc);
                 }
                 extensions.destroyPbuffer(pbuf);
             }
         }
     }
-    return NULL;
+    return nullptr;
 }
 
 SkWGLPbufferContext::~SkWGLPbufferContext() {
     SkASSERT(fExtensions.hasExtension(fDC, "WGL_ARB_pbuffer"));
     wglDeleteContext(fGLRC);
     fExtensions.releasePbufferDC(fPbuffer, fDC);
     fExtensions.destroyPbuffer(fPbuffer);
 }
 
 SkWGLPbufferContext::SkWGLPbufferContext(HPBUFFER pbuffer, HDC dc, HGLRC glrc)
     : fPbuffer(pbuffer)
     , fDC(dc)
     , fGLRC(glrc) {
 }