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

cc/trees/occlusion_tracker.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/trees/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/base/region.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 template <typename LayerType>
 OcclusionTracker<LayerType>::OcclusionTracker(
     const gfx::Rect& screen_space_clip_rect)
     : screen_space_clip_rect_(screen_space_clip_rect),
-      occluding_screen_space_rects_(NULL),
-      non_occluding_screen_space_rects_(NULL) {}
+      occluding_screen_space_rects_(nullptr),
+      non_occluding_screen_space_rects_(nullptr) {
+}
 
 template <typename LayerType>
 OcclusionTracker<LayerType>::~OcclusionTracker() {}
 
 template <typename LayerType>
 Occlusion OcclusionTracker<LayerType>::GetCurrentOcclusionForLayer(
     const gfx::Transform& draw_transform) const {
   DCHECK(!stack_.empty());
   const StackObject& back = stack_.back();
   return Occlusion(draw_transform,
@@ skipping 112 matching lines @@
   return layer->hide_layer_and_subtree() ||
          (layer->parent() && LayerIsHidden(layer->parent()));
 }
 
 template <typename LayerType>
 void OcclusionTracker<LayerType>::EnterRenderTarget(
     const LayerType* new_target) {
   if (!stack_.empty() && stack_.back().target == new_target)
     return;
 
-  const LayerType* old_target = NULL;
+  const LayerType* old_target = nullptr;
   const typename LayerType::RenderSurfaceType* old_occlusion_immune_ancestor =
-      NULL;
+      nullptr;
   if (!stack_.empty()) {
     old_target = stack_.back().target;
     old_occlusion_immune_ancestor =
         old_target->render_surface()->nearest_occlusion_immune_ancestor();
   }
   const typename LayerType::RenderSurfaceType* new_occlusion_immune_ancestor =
       new_target->render_surface()->nearest_occlusion_immune_ancestor();
 
   stack_.push_back(StackObject(new_target));
 
@@ skipping 10 matching lines @@
   bool have_transform_from_screen_to_new_target = false;
   gfx::Transform inverse_new_target_screen_space_transform(
       // Note carefully, not used if screen space transform is uninvertible.
       gfx::Transform::kSkipInitialization);
   if (SurfaceTransformsToScreenKnown(new_target->render_surface())) {
     have_transform_from_screen_to_new_target =
         new_target->render_surface()->screen_space_transform().GetInverse(
             &inverse_new_target_screen_space_transform);
   }
 
-  bool entering_root_target = new_target->parent() == NULL;
+  bool entering_root_target = new_target->parent() == nullptr;
 
   bool copy_outside_occlusion_forward =
       stack_.size() > 1 &&
       !entering_unoccluded_subtree &&
       have_transform_from_screen_to_new_target &&
       !entering_root_target;
   if (!copy_outside_occlusion_forward)
     return;
 
   int last_index = stack_.size() - 1;
@@ skipping 346 matching lines @@
   for (size_t i = 0; i < occluded.GetRegionComplexity(); ++i)
     visible_region.Subtract(occluded.GetRect(i));
   return visible_region;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTracker<Layer>;
 template class OcclusionTracker<LayerImpl>;
 
 }  // namespace cc