[C++11 Allowed Features] Declares a type-safe null pointer converting from NULL to nullptr in src/…

cc/resources/resource_provider.cc

 // Copyright 2012 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 194 matching lines @@
 };
 
 }  // namespace
 
 ResourceProvider::Resource::Resource()
     : child_id(0),
       gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       gl_read_lock_query_id(0),
-      pixels(NULL),
+      pixels(nullptr),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
       allow_overlay(false),
-      read_lock_fence(NULL),
+      read_lock_fence(nullptr),
       size(),
       origin(Internal),
       target(0),
       original_filter(0),
       filter(0),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(0),
       hint(TextureHintImmutable),
       type(InvalidType),
       format(RGBA_8888),
-      shared_bitmap(NULL) {
+      shared_bitmap(nullptr) {
 }
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(GLuint texture_id,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum target,
                                      GLenum filter,
                                      GLenum texture_pool,
                                      GLint wrap_mode,
                                      TextureHint hint,
                                      ResourceFormat format)
     : child_id(0),
       gl_id(texture_id),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       gl_read_lock_query_id(0),
-      pixels(NULL),
+      pixels(nullptr),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
       allow_overlay(false),
-      read_lock_fence(NULL),
+      read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(target),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(texture_pool),
       wrap_mode(wrap_mode),
       hint(hint),
       type(GLTexture),
       format(format),
-      shared_bitmap(NULL) {
+      shared_bitmap(nullptr) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
   DCHECK_EQ(origin == Internal, !!texture_pool);
 }
 
 ResourceProvider::Resource::Resource(uint8_t* pixels,
                                      SharedBitmap* bitmap,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum filter,
                                      GLint wrap_mode)
     : child_id(0),
       gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       gl_read_lock_query_id(0),
       pixels(pixels),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(!!bitmap),
       allow_overlay(false),
-      read_lock_fence(NULL),
+      read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureHintImmutable),
       type(Bitmap),
       format(RGBA_8888),
       shared_bitmap(bitmap) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
   DCHECK(origin == Delegated || pixels);
   if (bitmap)
     shared_bitmap_id = bitmap->id();
 }
 
 ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum filter,
                                      GLint wrap_mode)
     : child_id(0),
       gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       gl_read_lock_query_id(0),
-      pixels(NULL),
+      pixels(nullptr),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(true),
       allow_overlay(false),
-      read_lock_fence(NULL),
+      read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureHintImmutable),
       type(Bitmap),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
-      shared_bitmap(NULL) {
+      shared_bitmap(nullptr) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
 ResourceProvider::Child::Child() : marked_for_deletion(false) {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
@@ skipping 281 matching lines @@
         GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
         resource->gl_id = 0;
         if (!lost_resource)
           sync_point = gl->InsertSyncPointCHROMIUM();
       }
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       base::SharedMemory* shared_memory = resource->mailbox.shared_memory();
       if (resource->pixels && shared_memory) {
         DCHECK(shared_memory->memory() == resource->pixels);
-        resource->pixels = NULL;
+        resource->pixels = nullptr;
         delete resource->shared_bitmap;
-        resource->shared_bitmap = NULL;
+        resource->shared_bitmap = nullptr;
       }
     }
     resource->release_callback_impl.Run(
         sync_point, lost_resource, blocking_main_thread_task_runner_);
   }
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
     resource->gl_id = 0;
   }
   if (resource->shared_bitmap) {
     DCHECK(resource->origin != Resource::External);
     DCHECK_EQ(Bitmap, resource->type);
     delete resource->shared_bitmap;
-    resource->pixels = NULL;
+    resource->pixels = nullptr;
   }
   if (resource->pixels) {
     DCHECK(resource->origin == Resource::Internal);
     delete[] resource->pixels;
   }
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
@@ skipping 948 matching lines @@
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   if (!resource->gl_pixel_buffer_id)
     resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   unsigned bytes_per_pixel = BitsPerPixel(resource->format) / 8;
   gl->BufferData(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->size.height() *
                      RoundUp(bytes_per_pixel * resource->size.width(), 4u),
-                 NULL,
+                 nullptr,
                  GL_DYNAMIC_DRAW);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
 void ResourceProvider::ReleasePixelBuffer(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::ReleasePixelBuffer");
 
   Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
@@ skipping 13 matching lines @@
   }
 
   DCHECK_EQ(GLTexture, resource->type);
   if (!resource->gl_pixel_buffer_id)
     return;
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   gl->BufferData(
-      GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0, NULL, GL_DYNAMIC_DRAW);
+      GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0, nullptr, GL_DYNAMIC_DRAW);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
 uint8_t* ResourceProvider::MapPixelBuffer(ResourceId id, int* stride) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::MapPixelBuffer");
 
   Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
@@ skipping 91 matching lines @@
                     resource->gl_upload_query_id);
   if (allocate) {
     gl->AsyncTexImage2DCHROMIUM(GL_TEXTURE_2D,
                                 0, /* level */
                                 GLInternalFormat(resource->format),
                                 resource->size.width(),
                                 resource->size.height(),
                                 0, /* border */
                                 GLDataFormat(resource->format),
                                 GLDataType(resource->format),
-                                NULL);
+                                nullptr);
   } else {
     gl->AsyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
                                    0, /* level */
                                    0, /* x */
                                    0, /* y */
                                    resource->size.width(),
                                    resource->size.height(),
                                    GLDataFormat(resource->format),
                                    GLDataType(resource->format),
-                                   NULL);
+                                   nullptr);
   }
   gl->EndQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 
   resource->pending_set_pixels = true;
   resource->set_pixels_completion_forced = false;
 }
 
 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
@@ skipping 124 matching lines @@
     if (format != ETC1) {
       GLC(gl,
           gl->TexImage2D(GL_TEXTURE_2D,
                          0,
                          GLInternalFormat(format),
                          size.width(),
                          size.height(),
                          0,
                          GLDataFormat(format),
                          GLDataType(format),
-                         NULL));
+                         nullptr));
     }
   }
 }
 
 void ResourceProvider::BindImageForSampling(Resource* resource) {
   GLES2Interface* gl = ContextGL();
   DCHECK(resource->gl_id);
   DCHECK(resource->image_id);
 
   // Release image currently bound to texture.
@@ skipping 69 matching lines @@
 }
 
 GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 GLES2Interface* ResourceProvider::ContextGL() const {
   ContextProvider* context_provider = output_surface_->context_provider();
-  return context_provider ? context_provider->ContextGL() : NULL;
+  return context_provider ? context_provider->ContextGL() : nullptr;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
-  return context_provider ? context_provider->GrContext() : NULL;
+  return context_provider ? context_provider->GrContext() : nullptr;
 }
 
 }  // namespace cc