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

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
@@ skipping 17 matching lines @@
 #include "cc/trees/proxy.h"
 #include "ui/gfx/box_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
-    : parent_(NULL),
-      scroll_parent_(NULL),
-      clip_parent_(NULL),
+    : parent_(nullptr),
+      scroll_parent_(nullptr),
+      clip_parent_(nullptr),
       mask_layer_id_(-1),
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
-      scroll_offset_delegate_(NULL),
-      scroll_clip_layer_(NULL),
+      scroll_offset_delegate_(nullptr),
+      scroll_clip_layer_(nullptr),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       have_scroll_event_handlers_(false),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       stacking_order_changed_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       layer_property_changed_(false),
       masks_to_bounds_(false),
@@ skipping 480 matching lines @@
                                                : Layer::INVALID_ID);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
   layer->SetScrollOffsetAndDelta(
       scroll_offset_,
       layer->ScrollDelta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2dF());
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
-  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<LayerImpl*>::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<LayerImpl*>::iterator it = clip_children_->begin();
         it != clip_children_->end(); ++it)
       clip_children->insert(layer->layer_tree_impl()->LayerById((*it)->id()));
     layer->SetClipChildren(clip_children);
   } else {
-    layer->SetClipChildren(NULL);
+    layer->SetClipChildren(nullptr);
   }
 
   layer->PassCopyRequests(&copy_requests_);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
@@ skipping 245 matching lines @@
     replica_layer_->SetParent(this);
   NoteLayerPropertyChangedForSubtree();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
   return replica_layer_.Pass();
 }
 
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
-  return NULL;
+  return nullptr;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
   draws_content_ = draws_content;
   NoteLayerPropertyChanged();
 }
 
@@ skipping 474 matching lines @@
     return;
 
   scrollbar_animation_controller_ =
       layer_tree_impl_->CreateScrollbarAnimationController(this);
 }
 
 void LayerImpl::ClearScrollbars() {
   if (!scrollbars_)
     return;
 
-  scrollbars_.reset(NULL);
+  scrollbars_.reset(nullptr);
 }
 
 void LayerImpl::AddScrollbar(ScrollbarLayerImplBase* layer) {
   DCHECK(layer);
   DCHECK(!scrollbars_ || scrollbars_->find(layer) == scrollbars_->end());
   if (!scrollbars_)
     scrollbars_.reset(new ScrollbarSet());
 
   scrollbars_->insert(layer);
 }
@@ skipping 162 matching lines @@
     state->EndArray();
   }
 
   if (debug_info_.get()) {
     std::string str;
     debug_info_->AppendAsTraceFormat(&str);
     base::JSONReader json_reader;
     scoped_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str));
 
     if (debug_info_value->IsType(base::Value::TYPE_DICTIONARY)) {
-      base::DictionaryValue* dictionary_value = NULL;
+      base::DictionaryValue* dictionary_value = nullptr;
       bool converted_to_dictionary =
           debug_info_value->GetAsDictionary(&dictionary_value);
       DCHECK(converted_to_dictionary);
       for (base::DictionaryValue::Iterator it(*dictionary_value); !it.IsAtEnd();
            it.Advance()) {
         state->SetValue(it.key().data(), it.value().DeepCopy());
       }
     } else {
       NOTREACHED();
     }
@@ skipping 16 matching lines @@
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc