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

cc/output/software_renderer.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/output/software_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 60 matching lines @@
 }
 
 SoftwareRenderer::SoftwareRenderer(RendererClient* client,
                                    const LayerTreeSettings* settings,
                                    OutputSurface* output_surface,
                                    ResourceProvider* resource_provider)
     : DirectRenderer(client, settings, output_surface, resource_provider),
       is_scissor_enabled_(false),
       is_backbuffer_discarded_(false),
       output_device_(output_surface->software_device()),
-      current_canvas_(NULL) {
+      current_canvas_(nullptr) {
   if (resource_provider_) {
     capabilities_.max_texture_size = resource_provider_->max_texture_size();
     capabilities_.best_texture_format =
         resource_provider_->best_texture_format();
   }
   // The updater can access bitmaps while the SoftwareRenderer is using them.
   capabilities_.allow_partial_texture_updates = true;
   capabilities_.using_partial_swap = true;
 
   capabilities_.using_shared_memory_resources = true;
 
   capabilities_.allow_rasterize_on_demand = true;
 }
 
 SoftwareRenderer::~SoftwareRenderer() {}
 
 const RendererCapabilitiesImpl& SoftwareRenderer::Capabilities() const {
   return capabilities_;
 }
 
 void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
   root_canvas_ = output_device_->BeginPaint(
       gfx::ToEnclosingRect(frame->root_damage_rect));
 }
 
 void SoftwareRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::FinishDrawingFrame");
   current_framebuffer_lock_ = nullptr;
-  current_canvas_ = NULL;
-  root_canvas_ = NULL;
+  current_canvas_ = nullptr;
+  root_canvas_ = nullptr;
 
   current_frame_data_.reset(new SoftwareFrameData);
   output_device_->EndPaint(current_frame_data_.get());
 }
 
 void SoftwareRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
   TRACE_EVENT0("cc,benchmark", "SoftwareRenderer::SwapBuffers");
   CompositorFrame compositor_frame;
   compositor_frame.metadata = metadata;
   compositor_frame.software_frame_data = current_frame_data_.Pass();
@@ skipping 219 matching lines @@
   skia::RefPtr<SkDrawFilter> opacity_filter =
       skia::AdoptRef(new skia::OpacityDrawFilter(
           quad->opacity(), frame->disable_picture_quad_image_filtering));
   DCHECK(!current_canvas_->getDrawFilter());
   current_canvas_->setDrawFilter(opacity_filter.get());
 
   TRACE_EVENT0("cc",
                "SoftwareRenderer::DrawPictureQuad");
 
   quad->picture_pile->RasterDirect(
-      current_canvas_, quad->content_rect, quad->contents_scale, NULL);
+      current_canvas_, quad->content_rect, quad->contents_scale, nullptr);
 
-  current_canvas_->setDrawFilter(NULL);
+  current_canvas_->setDrawFilter(nullptr);
 }
 
 void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
                                           const SolidColorDrawQuad* quad) {
   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
       QuadVertexRect(), quad->rect, quad->visible_rect);
   current_paint_.setColor(quad->color);
   current_paint_.setAlpha(quad->opacity() * SkColorGetA(quad->color));
   current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
                             current_paint_);
@@ skipping 54 matching lines @@
                                           quad_rect,
                                           &current_paint_);
   }
 
   if (needs_layer)
     current_canvas_->restore();
 }
 
 void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
                                     const TileDrawQuad* quad) {
-  // |resource_provider_| can be NULL in resourceless software draws, which
+  // |resource_provider_| can be nullptr in resourceless software draws, which

[danakj, 2014/10/10 17:28:45]

just use null

   // should never produce tile quads in the first place.
   DCHECK(resource_provider_);
   DCHECK(IsSoftwareResource(quad->resource_id));
 
   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
                                                 quad->resource_id);
   if (!lock.valid())
     return;
   DCHECK_EQ(GL_CLAMP_TO_EDGE, lock.wrap_mode());
 
@@ skipping 158 matching lines @@
 }
 
 void SoftwareRenderer::DidChangeVisibility() {
   if (visible())
     EnsureBackbuffer();
   else
     DiscardBackbuffer();
 }
 
 }  // namespace cc