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

cc/layers/render_surface_impl.cc

 // Copyright 2011 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/layers/render_surface_impl.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 16 matching lines @@
 
 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
     : owning_layer_(owning_layer),
       surface_property_changed_(false),
       draw_opacity_is_animating_(false),
       target_surface_transforms_are_animating_(false),
       screen_space_transforms_are_animating_(false),
       is_clipped_(false),
       contributes_to_drawn_surface_(false),
       draw_opacity_(1),
-      nearest_occlusion_immune_ancestor_(NULL),
+      nearest_occlusion_immune_ancestor_(nullptr),
       target_render_surface_layer_index_history_(0),
       current_layer_index_history_(0) {
   damage_tracker_ = DamageTracker::Create();
 }
 
 RenderSurfaceImpl::~RenderSurfaceImpl() {}
 
 gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
   gfx::RectF drawable_content_rect =
       MathUtil::MapClippedRect(draw_transform_, content_rect_);
@@ skipping 129 matching lines @@
   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
   // and its reflection, it's currently not possible to apply a separate mask to
   // the reflection layer or correctly handle opacity in reflections (opacity
   // must be applied after drawing both the layer and its reflection). The
   // solution is to introduce yet another RenderSurfaceImpl to draw the layer
   // and its reflection in. For now we only apply a separate reflection mask if
   // the contents don't have a mask of their own.
   LayerImpl* mask_layer = owning_layer_->mask_layer();
   if (mask_layer &&
       (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
-    mask_layer = NULL;
+    mask_layer = nullptr;
 
   if (!mask_layer && for_replica) {
     mask_layer = owning_layer_->replica_layer()->mask_layer();
     if (mask_layer &&
         (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
-      mask_layer = NULL;
+      mask_layer = nullptr;
   }
 
   gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
   if (mask_layer) {
     gfx::Vector2dF owning_layer_draw_scale =
         MathUtil::ComputeTransform2dScaleComponents(
             owning_layer_->draw_transform(), 1.f);
     gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
         owning_layer_->content_bounds(),
         owning_layer_draw_scale.x(),
@@ skipping 27 matching lines @@
                visible_content_rect,
                render_pass_id,
                mask_resource_id,
                mask_uv_rect,
                owning_layer_->filters(),
                owning_layer_to_target_scale,
                owning_layer_->background_filters());
 }
 
 }  // namespace cc