Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/jitter_buffer.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/video_coding/jitter_buffer.h"
@@ skipping 42 matching lines @@
   return pair.second->GetState() != kStateEmpty;
 }
 
 void FrameList::InsertFrame(VCMFrameBuffer* frame) {
   insert(rbegin().base(), FrameListPair(frame->TimeStamp(), frame));
 }
 
 VCMFrameBuffer* FrameList::PopFrame(uint32_t timestamp) {
   FrameList::iterator it = find(timestamp);
   if (it == end())
-    return NULL;
+    return nullptr;
   VCMFrameBuffer* frame = it->second;
   erase(it);
   return frame;
 }
 
 VCMFrameBuffer* FrameList::Front() const {
   return begin()->second;
 }
 
 VCMFrameBuffer* FrameList::Back() const {
@@ skipping 450 matching lines @@
     }
   }
 
   *timestamp = oldest_frame->TimeStamp();
   return true;
 }
 
 VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) {
   CriticalSectionScoped cs(crit_sect_);
   if (!running_) {
-    return NULL;
+    return nullptr;
   }
   // Extract the frame with the desired timestamp.
   VCMFrameBuffer* frame = decodable_frames_.PopFrame(timestamp);
   bool continuous = true;
   if (!frame) {
     frame = incomplete_frames_.PopFrame(timestamp);
     if (frame)
       continuous = last_decoded_state_.ContinuousFrame(frame);
     else
-      return NULL;
+      return nullptr;
   }
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", timestamp, "Extract");
   // Frame pulled out from jitter buffer, update the jitter estimate.
   const bool retransmitted = (frame->GetNackCount() > 0);
   if (retransmitted) {
     if (WaitForRetransmissions())
       jitter_estimate_.FrameNacked();
   } else if (frame->Length() > 0) {
     // Ignore retransmitted and empty frames.
     if (waiting_for_completion_.latest_packet_time >= 0) {
@@ skipping 31 matching lines @@
   CriticalSectionScoped cs(crit_sect_);
   VCMFrameBuffer* frame_buffer = static_cast<VCMFrameBuffer*>(frame);
   RecycleFrameBuffer(frame_buffer);
 }
 
 // Gets frame to use for this timestamp. If no match, get empty frame.
 VCMFrameBufferEnum VCMJitterBuffer::GetFrame(const VCMPacket& packet,
                                              VCMFrameBuffer** frame,
                                              FrameList** frame_list) {
   *frame = incomplete_frames_.PopFrame(packet.timestamp);
-  if (*frame != NULL) {
+  if (*frame != nullptr) {
     *frame_list = &incomplete_frames_;
     return kNoError;
   }
   *frame = decodable_frames_.PopFrame(packet.timestamp);
-  if (*frame != NULL) {
+  if (*frame != nullptr) {
     *frame_list = &decodable_frames_;
     return kNoError;
   }
 
-  *frame_list = NULL;
+  *frame_list = nullptr;
   // No match, return empty frame.
   *frame = GetEmptyFrame();
-  if (*frame == NULL) {
+  if (*frame == nullptr) {
     // No free frame! Try to reclaim some...
     LOG(LS_WARNING) << "Unable to get empty frame; Recycling.";
     bool found_key_frame = RecycleFramesUntilKeyFrame();
     *frame = GetEmptyFrame();
     RTC_CHECK(*frame);
     if (!found_key_frame) {
       RecycleFrameBuffer(*frame);
       return kFlushIndicator;
     }
   }
@@ skipping 18 matching lines @@
   ++num_packets_;
   if (num_packets_ == 1) {
     time_first_packet_ms_ = clock_->TimeInMilliseconds();
   }
   // Does this packet belong to an old frame?
   if (last_decoded_state_.IsOldPacket(&packet)) {
     // Account only for media packets.
     if (packet.sizeBytes > 0) {
       num_discarded_packets_++;
       num_consecutive_old_packets_++;
-      if (stats_callback_ != NULL)
+      if (stats_callback_ != nullptr)
         stats_callback_->OnDiscardedPacketsUpdated(num_discarded_packets_);
     }
     // Update last decoded sequence number if the packet arrived late and
     // belongs to a frame with a timestamp equal to the last decoded
     // timestamp.
     last_decoded_state_.UpdateOldPacket(&packet);
     DropPacketsFromNackList(last_decoded_state_.sequence_num());
 
     // Also see if this old packet made more incomplete frames continuous.
     FindAndInsertContinuousFramesWithState(last_decoded_state_);
@@ skipping 125 matching lines @@
                 90 * kMaxDiscontinuousFramesTime) {
           return kFlushIndicator;
         }
       }
       break;
     }
     case kNoError:
     case kOutOfBoundsPacket:
     case kDuplicatePacket: {
       // Put back the frame where it came from.
-      if (frame_list != NULL) {
+      if (frame_list != nullptr) {
         frame_list->InsertFrame(frame);
       } else {
         RecycleFrameBuffer(frame);
       }
       ++num_duplicated_packets_;
       break;
     }
     case kFlushIndicator:
       RecycleFrameBuffer(frame);
       return kFlushIndicator;
@@ skipping 221 matching lines @@
 void VCMJitterBuffer::SetDecodeErrorMode(VCMDecodeErrorMode error_mode) {
   CriticalSectionScoped cs(crit_sect_);
   decode_error_mode_ = error_mode;
 }
 
 VCMFrameBuffer* VCMJitterBuffer::NextFrame() const {
   if (!decodable_frames_.empty())
     return decodable_frames_.Front();
   if (!incomplete_frames_.empty())
     return incomplete_frames_.Front();
-  return NULL;
+  return nullptr;
 }
 
 bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
   if (nack_mode_ == kNoNack) {
     return true;
   }
   // Make sure we don't add packets which are already too old to be decoded.
   if (!last_decoded_state_.in_initial_state()) {
     latest_received_sequence_number_ = LatestSequenceNumber(
         latest_received_sequence_number_, last_decoded_state_.sequence_num());
@@ skipping 77 matching lines @@
 
 void VCMJitterBuffer::RegisterStatsCallback(
     VCMReceiveStatisticsCallback* callback) {
   CriticalSectionScoped cs(crit_sect_);
   stats_callback_ = callback;
 }
 
 VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
   if (free_frames_.empty()) {
     if (!TryToIncreaseJitterBufferSize()) {
-      return NULL;
+      return nullptr;
     }
   }
   VCMFrameBuffer* frame = free_frames_.front();
   free_frames_.pop_front();
   return frame;
 }
 
 bool VCMJitterBuffer::TryToIncreaseJitterBufferSize() {
   if (max_number_of_frames_ >= kMaxNumberOfFrames)
     return false;
@@ skipping 52 matching lines @@
   if (frame.IsSessionComplete()) {
     if (frame.FrameType() == kVideoFrameKey) {
       ++receive_statistics_.key_frames;
       if (receive_statistics_.key_frames == 1) {
         LOG(LS_INFO) << "Received first complete key frame";
       }
     } else {
       ++receive_statistics_.delta_frames;
     }
 
-    if (stats_callback_ != NULL)
+    if (stats_callback_ != nullptr)
       stats_callback_->OnFrameCountsUpdated(receive_statistics_);
   }
 }
 
 void VCMJitterBuffer::UpdateAveragePacketsPerFrame(int current_number_packets) {
   if (frame_counter_ > kFastConvergeThreshold) {
     average_packets_per_frame_ =
         average_packets_per_frame_ * (1 - kNormalConvergeMultiplier) +
         current_number_packets * kNormalConvergeMultiplier;
   } else if (frame_counter_ > 0) {
@@ skipping 83 matching lines @@
   }
   return true;
 }
 
 void VCMJitterBuffer::RecycleFrameBuffer(VCMFrameBuffer* frame) {
   frame->Reset();
   free_frames_.push_back(frame);
 }
 
 }  // namespace webrtc