Replaced CriticalSectionWrapper with rtc::CriticalSection in rtp_rtcp module

webrtc/modules/rtp_rtcp/source/rtp_packet_history.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/rtp_packet_history.h"
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>   // memset
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 
 static const int kMinPacketRequestBytes = 50;
 
 RTPPacketHistory::RTPPacketHistory(Clock* clock)
     : clock_(clock),
-      critsect_(CriticalSectionWrapper::CreateCriticalSection()),
       store_(false),
       prev_index_(0) {}
 
 RTPPacketHistory::~RTPPacketHistory() {
 }
 
 void RTPPacketHistory::SetStorePacketsStatus(bool enable,
                                              uint16_t number_to_store) {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   if (enable) {
     if (store_) {
       LOG(LS_WARNING) << "Purging packet history in order to re-set status.";
       Free();
     }
     assert(!store_);
     Allocate(number_to_store);
   } else {
     Free();
   }
@@ skipping 11 matching lines @@
     return;
   }
 
   stored_packets_.clear();
 
   store_ = false;
   prev_index_ = 0;
 }
 
 bool RTPPacketHistory::StorePackets() const {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   return store_;
 }
 
 int32_t RTPPacketHistory::PutRTPPacket(const uint8_t* packet,
                                        size_t packet_length,
                                        int64_t capture_time_ms,
                                        StorageType type) {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   if (!store_) {
     return 0;
   }
 
   assert(packet);
   assert(packet_length > 3);
 
   if (packet_length > IP_PACKET_SIZE) {
     LOG(LS_WARNING) << "Failed to store RTP packet with length: "
                     << packet_length;
@@ skipping 32 matching lines @@
   stored_packets_[prev_index_].has_been_retransmitted = false;
 
   ++prev_index_;
   if (prev_index_ >= stored_packets_.size()) {
     prev_index_ = 0;
   }
   return 0;
 }
 
 bool RTPPacketHistory::HasRTPPacket(uint16_t sequence_number) const {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   if (!store_) {
     return false;
   }
 
   int32_t index = 0;
   bool found = FindSeqNum(sequence_number, &index);
   if (!found) {
     return false;
   }
 
   if (stored_packets_[index].length == 0) {
     // Invalid length.
     return false;
   }
   return true;
 }
 
 bool RTPPacketHistory::SetSent(uint16_t sequence_number) {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   if (!store_) {
     return false;
   }
 
   int32_t index = 0;
   bool found = FindSeqNum(sequence_number, &index);
   if (!found) {
     return false;
   }
 
   // Send time already set.
   if (stored_packets_[index].send_time != 0) {
     return false;
   }
 
   stored_packets_[index].send_time = clock_->TimeInMilliseconds();
   return true;
 }
 
 bool RTPPacketHistory::GetPacketAndSetSendTime(uint16_t sequence_number,
                                                int64_t min_elapsed_time_ms,
                                                bool retransmit,
                                                uint8_t* packet,
                                                size_t* packet_length,
                                                int64_t* stored_time_ms) {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   RTC_CHECK_GE(*packet_length, static_cast<size_t>(IP_PACKET_SIZE));
   if (!store_)
     return false;
 
   int32_t index = 0;
   bool found = FindSeqNum(sequence_number, &index);
   if (!found) {
     LOG(LS_WARNING) << "No match for getting seqNum " << sequence_number;
     return false;
   }
@@ skipping 35 matching lines @@
   // Get packet.
   size_t length = stored_packets_[index].length;
   memcpy(packet, stored_packets_[index].data, length);
   *packet_length = length;
   *stored_time_ms = stored_packets_[index].time_ms;
 }
 
 bool RTPPacketHistory::GetBestFittingPacket(uint8_t* packet,
                                             size_t* packet_length,
                                             int64_t* stored_time_ms) {
-  CriticalSectionScoped cs(critsect_.get());
+  rtc::CritScope cs(&critsect_);
   if (!store_)
     return false;
   int index = FindBestFittingPacket(*packet_length);
   if (index < 0)
     return false;
   GetPacket(index, packet, packet_length, stored_time_ms);
   return true;
 }
 
 // private, lock should already be taken
@@ skipping 46 matching lines @@
       min_diff = diff;
       best_index = static_cast<int>(i);
     }
   }
   return best_index;
 }
 
 RTPPacketHistory::StoredPacket::StoredPacket() {}
 
 }  // namespace webrtc