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

cc/layers/picture_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/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 39 matching lines @@
 const int kMinHeightForGpuRasteredTile = 128;
 
 // When making odd-sized tiles, round them up to increase the chances
 // of using the same tile size.
 const int kTileRoundUp = 64;
 
 }  // namespace
 
 namespace cc {
 
-PictureLayerImpl::Pair::Pair() : active(NULL), pending(NULL) {
+PictureLayerImpl::Pair::Pair() : active(nullptr), pending(nullptr) {
 }
 
 PictureLayerImpl::Pair::Pair(PictureLayerImpl* active_layer,
                              PictureLayerImpl* pending_layer)
     : active(active_layer), pending(pending_layer) {
 }
 
 PictureLayerImpl::Pair::~Pair() {
 }
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
-      twin_layer_(NULL),
+      twin_layer_(nullptr),
       pile_(PicturePileImpl::Create()),
       ideal_page_scale_(0.f),
       ideal_device_scale_(0.f),
       ideal_source_scale_(0.f),
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
@@ skipping 21 matching lines @@
 void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
   // It's possible this layer was never drawn or updated (e.g. because it was
   // a descendant of an opacity 0 layer).
   DoPostCommitInitializationIfNeeded();
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
 
   LayerImpl::PushPropertiesTo(base_layer);
 
   // When the pending tree pushes to the active tree, the pending twin
   // becomes recycled.
-  layer_impl->twin_layer_ = NULL;
-  twin_layer_ = NULL;
+  layer_impl->twin_layer_ = nullptr;
+  twin_layer_ = nullptr;
 
   layer_impl->pile_ = pile_;
 
   DCHECK(!pile_->is_solid_color() || !tilings_->num_tilings());
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
     tilings_->SetClient(this);
 
@@ skipping 502 matching lines @@
   return pile_.get();
 }
 
 const Region* PictureLayerImpl::GetInvalidation() {
   return &invalidation_;
 }
 
 const PictureLayerTiling* PictureLayerImpl::GetTwinTiling(
     const PictureLayerTiling* tiling) const {
   if (!twin_layer_)
-    return NULL;
+    return nullptr;
   return twin_layer_->tilings_->TilingAtScale(tiling->contents_scale());
 }
 
 PictureLayerTiling* PictureLayerImpl::GetRecycledTwinTiling(
     const PictureLayerTiling* tiling) {
   PictureLayerImpl* recycled_twin = GetRecycledTwinLayer();
   if (!recycled_twin || !recycled_twin->tilings_)
-    return NULL;
+    return nullptr;
   return recycled_twin->tilings_->TilingAtScale(tiling->contents_scale());
 }
 
 size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
   return layer_tree_impl()->settings().max_tiles_for_interest_area;
 }
 
 float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
   float skewport_target_time_in_frames =
       layer_tree_impl()->use_gpu_rasterization()
@@ skipping 230 matching lines @@
 
 inline float PositiveRatio(float float1, float float2) {
   DCHECK_GT(float1, 0);
   DCHECK_GT(float2, 0);
   return float1 > float2 ? float1 / float2 : float2 / float1;
 }
 
 }  // namespace
 
 void PictureLayerImpl::AddTilingsForRasterScale() {
-  PictureLayerTiling* high_res = NULL;
-  PictureLayerTiling* low_res = NULL;
+  PictureLayerTiling* high_res = nullptr;
+  PictureLayerTiling* low_res = nullptr;
 
-  PictureLayerTiling* previous_low_res = NULL;
+  PictureLayerTiling* previous_low_res = nullptr;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->contents_scale() == raster_contents_scale_)
       high_res = tiling;
     if (tiling->contents_scale() == low_res_raster_contents_scale_)
       low_res = tiling;
     if (tiling->resolution() == LOW_RESOLUTION)
       previous_low_res = tiling;
 
     // Reset all tilings to non-ideal until the end of this function.
@@ skipping 482 matching lines @@
       // from the tile.
       if (tiling->IsTileRequiredForActivation(tile) && !tile->IsReadyToDraw())
         return false;
     }
   }
 
   return true;
 }
 
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator()
-    : layer_(NULL), current_stage_(arraysize(stages_)) {
+    : layer_(nullptr), current_stage_(arraysize(stages_)) {
 }
 
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator(
     PictureLayerImpl* layer,
     bool prioritize_low_res)
     : layer_(layer), current_stage_(0) {
   DCHECK(layer_);
 
   // Early out if the layer has no tilings.
   if (!layer_->tilings_ || !layer_->tilings_->num_tilings()) {
@@ skipping 98 matching lines @@
     IteratorType index = stages_[current_stage_].iterator_type;
     TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type;
 
     if (iterators_[index] && iterators_[index].get_type() == tile_type)
       break;
     ++current_stage_;
   }
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator()
-    : layer_(NULL),
+    : layer_(nullptr),
       tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES),
       current_category_(PictureLayerTiling::EVENTUALLY),
       current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
       current_tiling_(0u) {
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
     PictureLayerImpl* layer,
     TreePriority tree_priority)
     : layer_(layer),
@@ skipping 132 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc