[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 30 matching lines @@
 const float kCpuSkewportTargetTimeInFrames = 60.0f;
 
 // Don't pre-rasterize on the GPU (except for kBackflingGuardDistancePixels in
 // TileManager::BinFromTilePriority).
 const float kGpuSkewportTargetTimeInFrames = 0.0f;
 
 }  // 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 29 matching lines @@
   // with new tiles (due to invalidation). This resets all active priorities on
   // the to-be-recycled tiling to ensure replaced tiles don't linger and take
   // memory (due to a stale 'active' priority).
   if (layer_impl->tilings_)
     layer_impl->tilings_->DidBecomeRecycled();
 
   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 490 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 174 matching lines @@
     float twin_min_acceptable_scale =
         std::min(twin->ideal_contents_scale_, twin->raster_contents_scale_);
     // Ignore 0 scale in case CalculateContentsScale() has never been
     // called for active twin.
     if (twin_min_acceptable_scale != 0.0f) {
       min_acceptable_scale =
           std::min(min_acceptable_scale, twin_min_acceptable_scale);
     }
   }
 
-  PictureLayerTiling* high_res = NULL;
-  PictureLayerTiling* low_res = NULL;
+  PictureLayerTiling* high_res = nullptr;
+  PictureLayerTiling* low_res = nullptr;
 
   // First pass: ready to draw tiles in acceptable but non-ideal tilings are
   // marked as required for activation so that their textures are not thrown
   // away; any non-ready tiles are not marked as required.
   Region missing_region = rect;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     DCHECK(tiling->has_ever_been_updated());
 
     if (tiling->resolution() == LOW_RESOLUTION) {
@@ skipping 15 matching lines @@
       missing_region.Subtract(iter.geometry_rect());
       iter->MarkRequiredForActivation();
     }
   }
   DCHECK(high_res) << "There must be one high res tiling";
 
   // If these pointers are null (because no twin, no matching tiling, or the
   // simpification just below), then high res tiles will be required to fill any
   // holes left by the first pass above.  If the pointers are valid, then this
   // layer is allowed to skip any tiles that are not ready on its twin.
-  const PictureLayerTiling* twin_high_res = NULL;
-  const PictureLayerTiling* twin_low_res = NULL;
+  const PictureLayerTiling* twin_high_res = nullptr;
+  const PictureLayerTiling* twin_low_res = nullptr;
 
   if (twin_layer_) {
     // As a simplification, only allow activating to skip twin tiles that the
     // active layer is also missing when both this layer and its twin have
     // "simple" sets of tilings: only 2 tilings (high and low) or only 1 high
     // res tiling. This avoids having to iterate/track coverage of non-ideal
     // tilings during the last draw call on the active layer.
     if (tilings_->num_tilings() <= 2 &&
         twin_layer_->tilings_->num_tilings() <= tilings_->num_tilings()) {
-      twin_low_res = low_res ? GetTwinTiling(low_res) : NULL;
-      twin_high_res = high_res ? GetTwinTiling(high_res) : NULL;
+      twin_low_res = low_res ? GetTwinTiling(low_res) : nullptr;
+      twin_high_res = high_res ? GetTwinTiling(high_res) : nullptr;
     }
 
     // If this layer and its twin have different transforms, then don't compare
     // them and only allow activating to high res tiles, since tiles on each
     // layer will be in different places on screen.
     if (layer_tree_impl()->RequiresHighResToDraw() ||
         bounds() != twin_layer_->bounds() ||
         draw_properties().screen_space_transform !=
             twin_layer_->draw_properties().screen_space_transform) {
-      twin_high_res = NULL;
-      twin_low_res = NULL;
+      twin_high_res = nullptr;
+      twin_low_res = nullptr;
     }
   }
 
   // As a second pass, mark as required any visible high res tiles not filled in
   // by acceptable non-ideal tiles from the first pass.
   if (MarkVisibleTilesAsRequired(
           high_res, twin_high_res, rect, missing_region)) {
     // As an optional third pass, if a high res tile was skipped because its
     // twin was also missing, then fall back to mark low res tiles as required
     // in case the active twin is substituting those for missing high res
@@ skipping 108 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 477 matching lines @@
 
       if (tile->required_for_activation() && !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 100 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