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

cc/trees/layer_sorter.cc

 // Copyright 2011 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/trees/layer_sorter.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 #include <vector>
@@ skipping 300 matching lines @@
       continue;
     for (size_t nb = na + 1; nb < nodes_.size(); nb++) {
       GraphNode& node_b = nodes_[nb];
       if (!node_b.layer->DrawsContent() && !node_b.layer->render_surface())
         continue;
       float weight = 0.f;
       ABCompareResult overlap_result = CheckOverlap(&node_a.shape,
                                                     &node_b.shape,
                                                     z_threshold,
                                                     &weight);
-      GraphNode* start_node = NULL;
-      GraphNode* end_node = NULL;
+      GraphNode* start_node = nullptr;
+      GraphNode* end_node = nullptr;
       if (overlap_result == ABeforeB) {
         start_node = &node_a;
         end_node = &node_b;
       } else if (overlap_result == BBeforeA) {
         start_node = &node_b;
         end_node = &node_a;
       }
 
       if (start_node) {
         DVLOG(2) << start_node->layer->id() << " -> " << end_node->layer->id();
@@ skipping 89 matching lines @@
 
     if (!active_edges_.size())
       break;
 
     // If there are still active edges but the list of nodes without incoming
     // edges is empty then we have run into a cycle. Break the cycle by finding
     // the node with the smallest overall incoming edge weight and use it. This
     // will favor nodes that have zero-weight incoming edges i.e. layers that
     // are being occluded by a layer that intersects them.
     float min_incoming_edge_weight = FLT_MAX;
-    GraphNode* next_node = NULL;
+    GraphNode* next_node = nullptr;
     for (size_t i = 0; i < nodes_.size(); i++) {
       if (nodes_[i].incoming.size() &&
           nodes_[i].incoming_edge_weight < min_incoming_edge_weight) {
         min_incoming_edge_weight = nodes_[i].incoming_edge_weight;
         next_node = &nodes_[i];
       }
     }
     DCHECK(next_node);
     // Remove all its incoming edges.
     for (size_t e = 0; e < next_node->incoming.size(); e++) {
@@ skipping 18 matching lines @@
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
 
   nodes_.clear();
   edges_.clear();
   active_edges_.clear();
 }
 
 }  // namespace cc