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

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 1083 matching lines @@
   skia::RefPtr<SkImage> filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   if (!quad->filters.IsEmpty()) {
     skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, contents_texture->size());
     if (filter) {
       skia::RefPtr<SkColorFilter> cf;
 
       {
-        SkColorFilter* colorfilter_rawptr = NULL;
+        SkColorFilter* colorfilter_rawptr = nullptr;
         filter->asColorFilter(&colorfilter_rawptr);
         cf = skia::AdoptRef(colorfilter_rawptr);
       }
 
       if (cf && cf->asColorMatrix(color_matrix) && !filter->getInput(0)) {
         // We have a single color matrix as a filter; apply it locally
         // in the compositor.
         use_color_matrix = true;
       } else {
         filter_bitmap =
@@ skipping 808 matching lines @@
   //   V - 128  : Turns unsigned V into signed V [-128,127]
   float yuv_adjust_rec601[3] = {
       -0.0625f, -0.5f, -0.5f,
   };
 
   // Same as above, but without the head and footroom.
   float yuv_adjust_rec601_jpeg[3] = {
       0.0f, -0.5f, -0.5f,
   };
 
-  float* yuv_to_rgb = NULL;
-  float* yuv_adjust = NULL;
+  float* yuv_to_rgb = nullptr;
+  float* yuv_adjust = nullptr;
 
   switch (quad->color_space) {
     case YUVVideoDrawQuad::REC_601:
       yuv_to_rgb = yuv_to_rgb_rec601;
       yuv_adjust = yuv_adjust_rec601;
       break;
     case YUVVideoDrawQuad::REC_601_JPEG:
       yuv_to_rgb = yuv_to_rgb_rec601_jpeg;
       yuv_adjust = yuv_adjust_rec601_jpeg;
       break;
@@ skipping 58 matching lines @@
         quad->texture_size,
         GL_TEXTURE_2D,
         GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
         GL_CLAMP_TO_EDGE,
         ResourceProvider::TextureHintImmutable,
         quad->texture_format);
   }
 
   SkCanvas canvas(on_demand_tile_raster_bitmap_);
   quad->picture_pile->RasterToBitmap(
-      &canvas, quad->content_rect, quad->contents_scale, NULL);
+      &canvas, quad->content_rect, quad->contents_scale, nullptr);
 
-  uint8_t* bitmap_pixels = NULL;
+  uint8_t* bitmap_pixels = nullptr;
   SkBitmap on_demand_tile_raster_bitmap_dest;
   SkColorType colorType = ResourceFormatToSkColorType(quad->texture_format);
   if (on_demand_tile_raster_bitmap_.colorType() != colorType) {
     on_demand_tile_raster_bitmap_.copyTo(&on_demand_tile_raster_bitmap_dest,
                                          colorType);
     // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
     // bitmap data. This check will be removed once crbug.com/293728 is fixed.
     CHECK_EQ(0u, on_demand_tile_raster_bitmap_dest.rowBytes() % 4);
     bitmap_pixels = reinterpret_cast<uint8_t*>(
         on_demand_tile_raster_bitmap_dest.getPixels());
@@ skipping 553 matching lines @@
     DCHECK_EQ(static_cast<unsigned>(GL_FRAMEBUFFER_COMPLETE),
               gl_->CheckFramebufferStatus(GL_FRAMEBUFFER));
   }
 
   GLuint buffer = 0;
   gl_->GenBuffers(1, &buffer);
   GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, buffer));
   GLC(gl_,
       gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                       4 * window_rect.size().GetArea(),
-                      NULL,
+                      nullptr,
                       GL_STREAM_READ));
 
   GLuint query = 0;
   gl_->GenQueriesEXT(1, &query);
   GLC(gl_, gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, query));
 
   GLC(gl_,
       gl_->ReadPixels(window_rect.x(),
                       window_rect.y(),
                       window_rect.width(),
                       window_rect.height(),
                       GL_RGBA,
                       GL_UNSIGNED_BYTE,
-                      NULL));
+                      nullptr));
 
   GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0));
 
   if (do_workaround) {
     // Clean up.
     GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));
     GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
     GLC(gl_, gl_->DeleteFramebuffers(1, &temporary_fbo));
     GLC(gl_, gl_->DeleteTextures(1, &temporary_texture));
   }
@@ skipping 25 matching lines @@
   DCHECK(!pending_async_read_pixels_.empty());
 
   if (query != 0) {
     GLC(gl_, gl_->DeleteQueriesEXT(1, &query));
   }
 
   PendingAsyncReadPixels* current_read = pending_async_read_pixels_.back();
   // Make sure we service the readbacks in order.
   DCHECK_EQ(source_buffer, current_read->buffer);
 
-  uint8* src_pixels = NULL;
+  uint8* src_pixels = nullptr;
   scoped_ptr<SkBitmap> bitmap;
 
   if (source_buffer != 0) {
     GLC(gl_,
         gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, source_buffer));
     src_pixels = static_cast<uint8*>(gl_->MapBufferCHROMIUM(
         GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
 
     if (src_pixels) {
       bitmap.reset(new SkBitmap);
@@ skipping 51 matching lines @@
                           window_rect.width(),
                           window_rect.height(),
                           0));
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
 }
 
 bool GLRenderer::UseScopedTexture(DrawingFrame* frame,
                                   const ScopedResource* texture,
                                   const gfx::Rect& viewport_rect) {
   DCHECK(texture->id());
-  frame->current_render_pass = NULL;
+  frame->current_render_pass = nullptr;
   frame->current_texture = texture;
 
   return BindFramebufferToTexture(frame, texture, viewport_rect);
 }
 
 void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_ = nullptr;
   output_surface_->BindFramebuffer();
 
   if (output_surface_->HasExternalStencilTest()) {
@@ skipping 409 matching lines @@
     TRACE_EVENT0("cc", "GLRenderer::videoYUVAProgram::initialize");
     program->Initialize(
         output_surface_->context_provider(), precision, SamplerType2D);
   }
   return program;
 }
 
 const GLRenderer::VideoStreamTextureProgram*
 GLRenderer::GetVideoStreamTextureProgram(TexCoordPrecision precision) {
   if (!Capabilities().using_egl_image)
-    return NULL;
+    return nullptr;
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
   VideoStreamTextureProgram* program =
       &video_stream_texture_program_[precision];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::streamTextureProgram::initialize");
     program->Initialize(
         output_surface_->context_provider(), precision, SamplerTypeExternalOES);
   }
   return program;
@@ skipping 121 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc