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

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 191 matching lines @@
     int after_right = -1;
     int after_bottom = -1;
     if (!live_tiles_rect_.IsEmpty()) {
       after_right =
           tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.right() - 1);
       after_bottom =
           tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.bottom() - 1);
     }
 
     // There is no recycled twin since this is run on the pending tiling.
-    PictureLayerTiling* recycled_twin = NULL;
+    PictureLayerTiling* recycled_twin = nullptr;
     DCHECK_EQ(recycled_twin, client_->GetRecycledTwinTiling(this));
     DCHECK_EQ(PENDING_TREE, client_->GetTree());
 
     // Drop tiles outside the new layer bounds if the layer shrank.
     for (int i = after_right + 1; i <= before_right; ++i) {
       for (int j = before_top; j <= before_bottom; ++j)
         RemoveTileAt(i, j, recycled_twin);
     }
     for (int i = before_left; i <= after_right; ++i) {
       for (int j = after_bottom + 1; j <= before_bottom; ++j)
@@ skipping 60 matching lines @@
     if (content_rect.IsEmpty())
       continue;
     // Since the content_rect includes border pixels already, don't include
     // borders when iterating to avoid double counting them.
     bool include_borders = false;
     for (TilingData::Iterator iter(
              &tiling_data_, content_rect, include_borders);
          iter;
          ++iter) {
       // There is no recycled twin since this is run on the pending tiling.
-      PictureLayerTiling* recycled_twin = NULL;
+      PictureLayerTiling* recycled_twin = nullptr;
       DCHECK_EQ(recycled_twin, client_->GetRecycledTwinTiling(this));
       DCHECK_EQ(PENDING_TREE, client_->GetTree());
       if (RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin))
         new_tile_keys.push_back(iter.index());
     }
   }
 
   if (recreate_invalidated_tiles && !new_tile_keys.empty()) {
     for (size_t i = 0; i < new_tile_keys.size(); ++i) {
       // Don't try to share a tile with the twin layer, it's been invalidated so
       // we have to make our own tile here.
-      const PictureLayerTiling* twin_tiling = NULL;
+      const PictureLayerTiling* twin_tiling = nullptr;
       CreateTile(new_tile_keys[i].first, new_tile_keys[i].second, twin_tiling);
     }
   }
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator()
-    : tiling_(NULL),
-      current_tile_(NULL),
+    : tiling_(nullptr),
+      current_tile_(nullptr),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator(
     const PictureLayerTiling* tiling,
     float dest_scale,
     const gfx::Rect& dest_rect)
     : tiling_(tiling),
       dest_rect_(dest_rect),
       dest_to_content_scale_(0),
-      current_tile_(NULL),
+      current_tile_(nullptr),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
   DCHECK(tiling_);
   if (dest_rect_.IsEmpty())
     return;
 
@@ skipping 30 matching lines @@
     return *this;
 
   bool first_time = tile_i_ < left_;
   bool new_row = false;
   tile_i_++;
   if (tile_i_ > right_) {
     tile_i_ = left_;
     tile_j_++;
     new_row = true;
     if (tile_j_ > bottom_) {
-      current_tile_ = NULL;
+      current_tile_ = nullptr;
       return *this;
     }
   }
 
   current_tile_ = tiling_->TileAt(tile_i_, tile_j_);
 
   // Calculate the current geometry rect.  Due to floating point rounding
   // and ToEnclosingRect, tiles might overlap in destination space on the
   // edges.
   gfx::Rect last_geometry_rect = current_geometry_rect_;
@@ skipping 69 matching lines @@
 
 bool PictureLayerTiling::RemoveTileAt(int i,
                                       int j,
                                       PictureLayerTiling* recycled_twin) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
   found->second->set_shared(false);
   tiles_.erase(found);
   if (recycled_twin) {
-    // Recycled twin does not also have a recycled twin, so pass NULL.
-    recycled_twin->RemoveTileAt(i, j, NULL);
+    // Recycled twin does not also have a recycled twin, so pass nullptr.

[danakj, 2014/10/10 17:28:45]

just use null

+    recycled_twin->RemoveTileAt(i, j, nullptr);
   }
   return true;
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   PictureLayerTiling* recycled_twin = client_->GetRecycledTwinTiling(this);
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     it->second->set_shared(false);
     if (recycled_twin)
-      recycled_twin->RemoveTileAt(it->first.first, it->first.second, NULL);
+      recycled_twin->RemoveTileAt(it->first.first, it->first.second, nullptr);
   }
   tiles_.clear();
 }
 
 gfx::Rect PictureLayerTiling::ComputeSkewport(
     double current_frame_time_in_seconds,
     const gfx::Rect& visible_rect_in_content_space) const {
   gfx::Rect skewport = visible_rect_in_content_space;
   if (last_impl_frame_time_in_seconds_ == 0.0)
     return skewport;
@@ skipping 551 matching lines @@
     case NOW:
       return &eviction_tiles_now_;
     case NOW_AND_REQUIRED_FOR_ACTIVATION:
       return &eviction_tiles_now_and_required_for_activation_;
   }
   NOTREACHED();
   return &eviction_tiles_eventually_;
 }
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
-    : tiling_(NULL), current_tile_(NULL) {}
+    : tiling_(nullptr), current_tile_(nullptr) {
+}
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     PictureLayerTiling* tiling)
-    : tiling_(tiling), phase_(VISIBLE_RECT), current_tile_(NULL) {
+    : tiling_(tiling), phase_(VISIBLE_RECT), current_tile_(nullptr) {
   if (!tiling_->has_visible_rect_tiles_) {
     AdvancePhase();
     return;
   }
 
   visible_iterator_ = TilingData::Iterator(&tiling_->tiling_data_,
                                            tiling_->current_visible_rect_,
                                            false /* include_borders */);
   if (!visible_iterator_) {
     AdvancePhase();
@@ skipping 35 matching lines @@
           continue;
 
         spiral_iterator_ = TilingData::SpiralDifferenceIterator(
             &tiling_->tiling_data_,
             tiling_->current_soon_border_rect_,
             tiling_->current_skewport_rect_,
             tiling_->current_visible_rect_);
         break;
       case EVENTUALLY_RECT:
         if (!tiling_->has_eventually_rect_tiles_) {
-          current_tile_ = NULL;
+          current_tile_ = nullptr;
           return;
         }
 
         spiral_iterator_ = TilingData::SpiralDifferenceIterator(
             &tiling_->tiling_data_,
             tiling_->current_eventually_rect_,
             tiling_->current_skewport_rect_,
             tiling_->current_soon_border_rect_);
         break;
     }
 
     while (spiral_iterator_) {
       current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(),
                                       spiral_iterator_.index_y());
       if (current_tile_ && TileNeedsRaster(current_tile_))
         break;
       ++spiral_iterator_;
     }
 
     if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) {
-      current_tile_ = NULL;
+      current_tile_ = nullptr;
       break;
     }
   } while (!spiral_iterator_);
 
   if (current_tile_)
     tiling_->UpdateTileAndTwinPriority(current_tile_);
 }
 
 PictureLayerTiling::TilingRasterTileIterator&
 PictureLayerTiling::TilingRasterTileIterator::
 operator++() {
-  current_tile_ = NULL;
+  current_tile_ = nullptr;
   while (!current_tile_ || !TileNeedsRaster(current_tile_)) {
     std::pair<int, int> next_index;
     switch (phase_) {
       case VISIBLE_RECT:
         ++visible_iterator_;
         if (!visible_iterator_) {
           AdvancePhase();
           return *this;
         }
         next_index = visible_iterator_.index();
         break;
       case SKEWPORT_RECT:
       case SOON_BORDER_RECT:
         ++spiral_iterator_;
         if (!spiral_iterator_) {
           AdvancePhase();
           return *this;
         }
         next_index = spiral_iterator_.index();
         break;
       case EVENTUALLY_RECT:
         ++spiral_iterator_;
         if (!spiral_iterator_) {
-          current_tile_ = NULL;
+          current_tile_ = nullptr;
           return *this;
         }
         next_index = spiral_iterator_.index();
         break;
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
 
   if (current_tile_)
     tiling_->UpdateTileAndTwinPriority(current_tile_);
   return *this;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
-    : eviction_tiles_(NULL), current_eviction_tiles_index_(0u) {
+    : eviction_tiles_(nullptr), current_eviction_tiles_index_(0u) {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
     TreePriority tree_priority,
     EvictionCategory category)
     : eviction_tiles_(tiling->GetEvictionTiles(tree_priority, category)),
       // Note: initializing to "0 - 1" works as overflow is well defined for
       // unsigned integers.
       current_eviction_tiles_index_(static_cast<size_t>(0) - 1) {
@@ skipping 25 matching lines @@
   DCHECK(*this);
   do {
     ++current_eviction_tiles_index_;
   } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
            !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
 
   return *this;
 }
 
 }  // namespace cc