Replace NULL with nullptr in all C++ files.

webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.h"
 
 #include <assert.h>
-#include <stdlib.h>  // NULL
+#include <stdlib.h>  // nullptr
 
 #include <algorithm>
 #include <limits>
 
 namespace webrtc {
 
 PartitionTreeNode::PartitionTreeNode(PartitionTreeNode* parent,
                                      const size_t* size_vector,
                                      size_t num_partitions,
                                      size_t this_size)
     : parent_(parent),
       this_size_(this_size),
       size_vector_(size_vector),
       num_partitions_(num_partitions),
       max_parent_size_(0),
       min_parent_size_(std::numeric_limits<int>::max()),
       packet_start_(false) {
   // If |this_size_| > INT_MAX, Cost() and CreateChildren() won't work properly.
   assert(this_size_ <= static_cast<size_t>(std::numeric_limits<int>::max()));
-  children_[kLeftChild] = NULL;
-  children_[kRightChild] = NULL;
+  children_[kLeftChild] = nullptr;
+  children_[kRightChild] = nullptr;
 }
 
 PartitionTreeNode* PartitionTreeNode::CreateRootNode(const size_t* size_vector,
                                                      size_t num_partitions) {
   PartitionTreeNode* root_node = new PartitionTreeNode(
-      NULL, &size_vector[1], num_partitions - 1, size_vector[0]);
+      nullptr, &size_vector[1], num_partitions - 1, size_vector[0]);
   root_node->set_packet_start(true);
   return root_node;
 }
 
 PartitionTreeNode::~PartitionTreeNode() {
   delete children_[kLeftChild];
   delete children_[kRightChild];
 }
 
 int PartitionTreeNode::Cost(size_t penalty) {
@@ skipping 33 matching lines @@
           std::min(min_parent_size_, this_size_int()));
       // "Right" child starts a new packet.
       children_[kRightChild]->set_packet_start(true);
       children_created = true;
     }
   }
   return children_created;
 }
 
 size_t PartitionTreeNode::NumPackets() {
-  if (parent_ == NULL) {
+  if (parent_ == nullptr) {
     // Root node is a "right" child by definition.
     return 1;
   }
   if (parent_->children_[kLeftChild] == this) {
     // This is a "left" child.
     return parent_->NumPackets();
   } else {
     // This is a "right" child.
     return 1 + parent_->NumPackets();
   }
 }
 
 PartitionTreeNode* PartitionTreeNode::GetOptimalNode(size_t max_size,
                                                      size_t penalty) {
   CreateChildren(max_size);
   PartitionTreeNode* left = children_[kLeftChild];
   PartitionTreeNode* right = children_[kRightChild];
-  if ((left == NULL) && (right == NULL)) {
+  if ((left == nullptr) && (right == nullptr)) {
     // This is a solution node; return it.
     return this;
-  } else if (left == NULL) {
+  } else if (left == nullptr) {
     // One child empty, return the other.
     return right->GetOptimalNode(max_size, penalty);
-  } else if (right == NULL) {
+  } else if (right == nullptr) {
     // One child empty, return the other.
     return left->GetOptimalNode(max_size, penalty);
   } else {
     PartitionTreeNode* first;
     PartitionTreeNode* second;
     if (left->Cost(penalty) <= right->Cost(penalty)) {
       first = left;
       second = right;
     } else {
       first = right;
       second = left;
     }
     first = first->GetOptimalNode(max_size, penalty);
     if (second->Cost(penalty) <= first->Cost(penalty)) {
       second = second->GetOptimalNode(max_size, penalty);
       // Compare cost estimate for "second" with actual cost for "first".
       if (second->Cost(penalty) < first->Cost(penalty)) {
         return second;
       }
     }
     return first;
   }
 }
 
 Vp8PartitionAggregator::Vp8PartitionAggregator(
     const RTPFragmentationHeader& fragmentation,
     size_t first_partition_idx,
     size_t last_partition_idx)
-    : root_(NULL),
+    : root_(nullptr),
       num_partitions_(last_partition_idx - first_partition_idx + 1),
       size_vector_(new size_t[num_partitions_]),
       largest_partition_size_(0) {
   assert(last_partition_idx >= first_partition_idx);
   assert(last_partition_idx < fragmentation.fragmentationVectorSize);
   for (size_t i = 0; i < num_partitions_; ++i) {
     size_vector_[i] =
         fragmentation.fragmentationLength[i + first_partition_idx];
     largest_partition_size_ =
         std::max(largest_partition_size_, size_vector_[i]);
@@ skipping 18 matching lines @@
 Vp8PartitionAggregator::FindOptimalConfiguration(size_t max_size,
                                                  size_t penalty) {
   assert(root_);
   assert(max_size >= largest_partition_size_);
   PartitionTreeNode* opt = root_->GetOptimalNode(max_size, penalty);
   ConfigVec config_vector(num_partitions_, 0);
   PartitionTreeNode* temp_node = opt;
   size_t packet_index = opt->NumPackets();
   for (size_t i = num_partitions_; i > 0; --i) {
     assert(packet_index > 0);
-    assert(temp_node != NULL);
+    assert(temp_node != nullptr);
     config_vector[i - 1] = packet_index - 1;
     if (temp_node->packet_start())
       --packet_index;
     temp_node = temp_node->parent();
   }
   return config_vector;
 }
 
 void Vp8PartitionAggregator::CalcMinMax(const ConfigVec& config,
                                         int* min_size,
@@ skipping 61 matching lines @@
       best_cost = cost;
     }
   }
   assert(num_fragments > 0);
   // TODO(mflodman) Assert disabled since it's falsely triggered, see issue 293.
   // assert(large_partition_size / num_fragments + 1 <= max_payload_size);
   return num_fragments;
 }
 
 }  // namespace webrtc