C++11 declares a type safe null pointer

content/common/gpu/media/rendering_helper.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/gpu/media/rendering_helper.h"
 
 #include <algorithm>
 #include <numeric>
 #include <vector>
 
@@ skipping 30 matching lines @@
                          GLenum type,
                          const char* source,
                          int size) {
   GLuint shader = glCreateShader(type);
   glShaderSource(shader, 1, &source, &size);
   glCompileShader(shader);
   int result = GL_FALSE;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
   if (!result) {
     char log[4096];
-    glGetShaderInfoLog(shader, arraysize(log), NULL, log);
+    glGetShaderInfoLog(shader, arraysize(log), nullptr, log);
     LOG(FATAL) << log;
   }
   glAttachShader(program, shader);
   glDeleteShader(shader);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 namespace content {
 
 RenderingHelperParams::RenderingHelperParams() {}
@@ skipping 66 matching lines @@
   screen_size_ =
       gfx::Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
   window_ = CreateWindowEx(0,
                            L"Static",
                            L"VideoDecodeAcceleratorTest",
                            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                            0,
                            0,
                            screen_size_.width(),
                            screen_size_.height(),
-                           NULL,
-                           NULL,
-                           NULL,
-                           NULL);
+                           nullptr,
+                           nullptr,
+                           nullptr,
+                           nullptr);
 #elif defined(USE_X11)
   Display* display = gfx::GetXDisplay();
   Screen* screen = DefaultScreenOfDisplay(display);
   screen_size_ = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
 
   CHECK(display);
 
   XSetWindowAttributes window_attributes;
   memset(&window_attributes, 0, sizeof(window_attributes));
   window_attributes.background_pixel =
@@ skipping 16 matching lines @@
   XStoreName(display, window_, "VideoDecodeAcceleratorTest");
   XSelectInput(display, window_, ExposureMask);
   XMapWindow(display, window_);
 #else
 #error unknown platform
 #endif
   CHECK(window_ != gfx::kNullAcceleratedWidget);
 
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(window_);
   gl_context_ = gfx::GLContext::CreateGLContext(
-      NULL, gl_surface_.get(), gfx::PreferIntegratedGpu);
+      nullptr, gl_surface_.get(), gfx::PreferIntegratedGpu);
   gl_context_->MakeCurrent(gl_surface_.get());
 
   CHECK_GT(params.window_sizes.size(), 0U);
   videos_.resize(params.window_sizes.size());
   LayoutRenderingAreas(params.window_sizes);
 
   if (render_as_thumbnails_) {
     CHECK_EQ(videos_.size(), 1U);
 
     GLint max_texture_size;
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
     CHECK_GE(max_texture_size, params.thumbnails_page_size.width());
     CHECK_GE(max_texture_size, params.thumbnails_page_size.height());
 
     thumbnails_fbo_size_ = params.thumbnails_page_size;
     thumbnail_size_ = params.thumbnail_size;
 
     glGenFramebuffersEXT(1, &thumbnails_fbo_id_);
     glGenTextures(1, &thumbnails_texture_id_);
     glBindTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
     glTexImage2D(GL_TEXTURE_2D,
                  0,
                  GL_RGB,
                  thumbnails_fbo_size_.width(),
                  thumbnails_fbo_size_.height(),
                  0,
                  GL_RGB,
                  GL_UNSIGNED_SHORT_5_6_5,
-                 NULL);
+                 nullptr);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glBindTexture(GL_TEXTURE_2D, 0);
 
     glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
                               GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D,
@@ skipping 58 matching lines @@
       program_, GL_VERTEX_SHADER, kVertexShader, arraysize(kVertexShader));
   CreateShader(program_,
                GL_FRAGMENT_SHADER,
                kFragmentShader,
                arraysize(kFragmentShader));
   glLinkProgram(program_);
   int result = GL_FALSE;
   glGetProgramiv(program_, GL_LINK_STATUS, &result);
   if (!result) {
     char log[4096];
-    glGetShaderInfoLog(program_, arraysize(log), NULL, log);
+    glGetShaderInfoLog(program_, arraysize(log), nullptr, log);
     LOG(FATAL) << log;
   }
   glUseProgram(program_);
   glDeleteProgram(program_);
 
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
   glUniform1i(glGetUniformLocation(program_, "tex"), 0);
   GLint tex_external = glGetUniformLocation(program_, "tex_external");
   if (tex_external != -1) {
     glUniform1i(tex_external, 1);
@@ skipping 12 matching lines @@
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   render_task_.Cancel();
 
   if (render_as_thumbnails_) {
     glDeleteTextures(1, &thumbnails_texture_id_);
     glDeleteFramebuffersEXT(1, &thumbnails_fbo_id_);
   }
 
   gl_context_->ReleaseCurrent(gl_surface_.get());
-  gl_context_ = NULL;
-  gl_surface_ = NULL;
+  gl_context_ = nullptr;
+  gl_surface_ = nullptr;
 
   Clear();
   done->Signal();
 }
 
 void RenderingHelper::CreateTexture(uint32 texture_target,
                                     uint32* texture_id,
                                     const gfx::Size& size,
                                     base::WaitableEvent* done) {
   if (base::MessageLoop::current() != message_loop_) {
@@ skipping 10 matching lines @@
   glBindTexture(texture_target, *texture_id);
   if (texture_target == GL_TEXTURE_2D) {
     glTexImage2D(GL_TEXTURE_2D,
                  0,
                  GL_RGBA,
                  size.width(),
                  size.height(),
                  0,
                  GL_RGBA,
                  GL_UNSIGNED_BYTE,
-                 NULL);
+                 nullptr);
   }
   glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   // OpenGLES2.0.25 section 3.8.2 requires CLAMP_TO_EDGE for NPOT textures.
   glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   done->Signal();
 }
 
@@ skipping 81 matching lines @@
 void* RenderingHelper::GetGLContext() {
   return gl_context_->GetHandle();
 }
 
 void* RenderingHelper::GetGLDisplay() {
   return gl_surface_->GetDisplay();
 }
 
 void RenderingHelper::Clear() {
   videos_.clear();
-  message_loop_ = NULL;
-  gl_context_ = NULL;
-  gl_surface_ = NULL;
+  message_loop_ = nullptr;
+  gl_context_ = nullptr;
+  gl_surface_ = nullptr;
 
   render_as_thumbnails_ = false;
   frame_count_ = 0;
   thumbnails_fbo_id_ = 0;
   thumbnails_texture_id_ = 0;
 
 #if defined(OS_WIN)
   if (window_)
     DestroyWindow(window_);
 #else
@@ skipping 138 matching lines @@
     scale = std::min(1.0f, scale);
 
     size_t w = scale * size.width();
     size_t h = scale * size.height();
     size_t x = offset_x[i % cols] + (widths[i % cols] - w) / 2;
     size_t y = offset_y[i / cols] + (heights[i / cols] - h) / 2;
     videos_[i].render_area = gfx::Rect(x, y, w, h);
   }
 }
 }  // namespace content