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

cc/layers/layer.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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/debug/trace_event.h"
@@ skipping 27 matching lines @@
 }
 
 Layer::Layer()
     : needs_push_properties_(false),
       num_dependents_need_push_properties_(false),
       stacking_order_changed_(false),
       // Layer IDs start from 1.
       layer_id_(g_next_layer_id.GetNext() + 1),
       ignore_set_needs_commit_(false),
       sorting_context_id_(0),
-      parent_(NULL),
-      layer_tree_host_(NULL),
+      parent_(nullptr),
+      layer_tree_host_(nullptr),
       scroll_clip_layer_id_(INVALID_ID),
       num_descendants_that_draw_content_(0),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       have_scroll_event_handlers_(false),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       is_root_for_isolated_group_(false),
       is_container_for_fixed_position_layers_(false),
       is_drawable_(false),
       draws_content_(false),
       hide_layer_and_subtree_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       force_render_surface_(false),
       transform_is_invertible_(true),
       background_color_(0),
       opacity_(1.f),
       blend_mode_(SkXfermode::kSrcOver_Mode),
-      scroll_parent_(NULL),
-      clip_parent_(NULL),
-      replica_layer_(NULL),
+      scroll_parent_(nullptr),
+      clip_parent_(nullptr),
+      replica_layer_(nullptr),
       raster_scale_(0.f),
-      client_(NULL) {
+      client_(nullptr) {
   layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
   layer_animation_controller_->set_value_provider(this);
 }
 
 Layer::~Layer() {
   // Our parent should be holding a reference to us so there should be no
   // way for us to be destroyed while we still have a parent.
   DCHECK(!parent());
   // Similarly we shouldn't have a layer tree host since it also keeps a
@@ skipping 131 matching lines @@
   DCHECK(!layer || !layer->HasAncestor(this));
 
   if (parent_should_know_need_push_properties()) {
     if (parent_)
       parent_->RemoveDependentNeedsPushProperties();
     if (layer)
       layer->AddDependentNeedsPushProperties();
   }
 
   parent_ = layer;
-  SetLayerTreeHost(parent_ ? parent_->layer_tree_host() : NULL);
+  SetLayerTreeHost(parent_ ? parent_->layer_tree_host() : nullptr);
 
   if (!layer_tree_host_)
     return;
   const LayerTreeSettings& settings = layer_tree_host_->settings();
   if (!settings.layer_transforms_should_scale_layer_contents)
     return;
 
   reset_raster_scale_to_unknown();
   if (mask_layer_.get())
     mask_layer_->reset_raster_scale_to_unknown();
@@ skipping 19 matching lines @@
 }
 
 void Layer::RemoveFromParent() {
   DCHECK(IsPropertyChangeAllowed());
   if (parent_)
     parent_->RemoveChildOrDependent(this);
 }
 
 void Layer::RemoveChildOrDependent(Layer* child) {
   if (mask_layer_.get() == child) {
-    mask_layer_->SetParent(NULL);
-    mask_layer_ = NULL;
+    mask_layer_->SetParent(nullptr);
+    mask_layer_ = nullptr;
     SetNeedsFullTreeSync();
     return;
   }
   if (replica_layer_.get() == child) {
-    replica_layer_->SetParent(NULL);
-    replica_layer_ = NULL;
+    replica_layer_->SetParent(nullptr);
+    replica_layer_ = nullptr;
     SetNeedsFullTreeSync();
     return;
   }
 
   for (LayerList::iterator iter = children_.begin();
        iter != children_.end();
        ++iter) {
     if (iter->get() != child)
       continue;
 
-    child->SetParent(NULL);
+    child->SetParent(nullptr);
     AddDrawableDescendants(-child->NumDescendantsThatDrawContent() -
                            (child->DrawsContent() ? 1 : 0));
     children_.erase(iter);
     SetNeedsFullTreeSync();
     return;
   }
 }
 
 void Layer::ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer) {
   DCHECK(reference);
@@ skipping 607 matching lines @@
   if (!layer->TransformIsAnimatingOnImplOnly() && !TransformIsAnimating())
     layer->SetTransformAndInvertibility(transform_, transform_is_invertible_);
   DCHECK(!(TransformIsAnimating() && layer->TransformIsAnimatingOnImplOnly()));
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
   layer->SetScrollClipLayer(scroll_clip_layer_id_);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
 
-  LayerImpl* scroll_parent = NULL;
+  LayerImpl* scroll_parent = nullptr;
   if (scroll_parent_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
   }
 
   layer->SetScrollParent(scroll_parent);
   if (scroll_children_) {
     std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>;
     for (std::set<Layer*>::iterator it = scroll_children_->begin();
          it != scroll_children_->end();
          ++it) {
       DCHECK_EQ((*it)->scroll_parent(), this);
       LayerImpl* scroll_child =
           layer->layer_tree_impl()->LayerById((*it)->id());
       DCHECK(scroll_child);
       scroll_children->insert(scroll_child);
     }
     layer->SetScrollChildren(scroll_children);
   } else {
-    layer->SetScrollChildren(NULL);
+    layer->SetScrollChildren(nullptr);
   }
 
-  LayerImpl* clip_parent = NULL;
+  LayerImpl* clip_parent = nullptr;
   if (clip_parent_) {
     clip_parent =
         layer->layer_tree_impl()->LayerById(clip_parent_->id());
     DCHECK(clip_parent);
   }
 
   layer->SetClipParent(clip_parent);
   if (clip_children_) {
     std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>;
     for (std::set<Layer*>::iterator it = clip_children_->begin();
         it != clip_children_->end(); ++it) {
       DCHECK_EQ((*it)->clip_parent(), this);
       LayerImpl* clip_child = layer->layer_tree_impl()->LayerById((*it)->id());
       DCHECK(clip_child);
       clip_children->insert(clip_child);
     }
     layer->SetClipChildren(clip_children);
   } else {
-    layer->SetClipChildren(NULL);
+    layer->SetClipChildren(nullptr);
   }
 
   // Adjust the scroll delta to be just the scrolls that have happened since
   // the BeginMainFrame was sent.  This happens for impl-side painting
   // in LayerImpl::ApplyScrollDeltasSinceBeginMainFrame in a separate tree walk.
   if (layer->layer_tree_impl()->settings().impl_side_painting) {
     layer->SetScrollOffset(scroll_offset_);
   } else {
     layer->SetScrollOffsetAndDelta(
         scroll_offset_,
@@ skipping 102 matching lines @@
 }
 
 bool Layer::IsSuitableForGpuRasterization() const {
   return true;
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat> Layer::TakeDebugInfo() {
   if (client_)
     return client_->TakeDebugInfo();
   else
-    return NULL;
+    return nullptr;
 }
 
 void Layer::CreateRenderSurface() {
   DCHECK(!draw_properties_.render_surface);
   draw_properties_.render_surface = make_scoped_ptr(new RenderSurface(this));
   draw_properties_.render_target = this;
 }
 
 void Layer::ClearRenderSurface() {
   draw_properties_.render_surface = nullptr;
@@ skipping 91 matching lines @@
   layer_animation_controller_->RemoveEventObserver(animation_observer);
 }
 
 SimpleEnclosedRegion Layer::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_content_rect());
   return SimpleEnclosedRegion();
 }
 
 ScrollbarLayerInterface* Layer::ToScrollbarLayer() {
-  return NULL;
+  return nullptr;
 }
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 bool Layer::SupportsLCDText() const {
   return false;
 }
 
 void Layer::RemoveFromScrollTree() {
   if (scroll_children_.get()) {
     std::set<Layer*> copy = *scroll_children_;
     for (std::set<Layer*>::iterator it = copy.begin(); it != copy.end(); ++it)
-      (*it)->SetScrollParent(NULL);
+      (*it)->SetScrollParent(nullptr);
   }
 
   DCHECK(!scroll_children_);
-  SetScrollParent(NULL);
+  SetScrollParent(nullptr);
 }
 
 void Layer::RemoveFromClipTree() {
   if (clip_children_.get()) {
     std::set<Layer*> copy = *clip_children_;
     for (std::set<Layer*>::iterator it = copy.begin(); it != copy.end(); ++it)
-      (*it)->SetClipParent(NULL);
+      (*it)->SetClipParent(nullptr);
   }
 
   DCHECK(!clip_children_);
-  SetClipParent(NULL);
+  SetClipParent(nullptr);
 }
 
 void Layer::AddDrawableDescendants(int num) {
   DCHECK_GE(num_descendants_that_draw_content_, 0);
   DCHECK_GE(num_descendants_that_draw_content_ + num, 0);
   if (num == 0)
     return;
   num_descendants_that_draw_content_ += num;
   SetNeedsCommit();
   if (parent())
     parent()->AddDrawableDescendants(num);
 }
 
 void Layer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 bool Layer::HasDelegatedContent() const {
   return false;
 }
 
 }  // namespace cc