Swap use of CriticalSectionWrapper for rtc::CriticalSection in webrtc/video.

webrtc/video/call_stats.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/video/call_stats.h"
 
 #include <assert.h>
 
 #include <algorithm>
 
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 namespace {
 // Time interval for updating the observers.
 const int64_t kUpdateIntervalMs = 1000;
 // Weight factor to apply to the average rtt.
 const float kWeightFactor = 0.3f;
 
 void RemoveOldReports(int64_t now, std::list<CallStats::RttTime>* reports) {
@@ skipping 57 matching lines @@
   }
 
  private:
   CallStats* owner_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcpObserver);
 };
 
 CallStats::CallStats(Clock* clock)
     : clock_(clock),
-      crit_(CriticalSectionWrapper::CreateCriticalSection()),
       rtcp_rtt_stats_(new RtcpObserver(this)),
       last_process_time_(clock_->TimeInMilliseconds()),
       max_rtt_ms_(0),
       avg_rtt_ms_(0) {}
 
 CallStats::~CallStats() {
   assert(observers_.empty());
 }
 
 int64_t CallStats::TimeUntilNextProcess() {
   return last_process_time_ + kUpdateIntervalMs - clock_->TimeInMilliseconds();
 }
 
 int32_t CallStats::Process() {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&crit_);
   int64_t now = clock_->TimeInMilliseconds();
   if (now < last_process_time_ + kUpdateIntervalMs)
     return 0;
 
   last_process_time_ = now;
 
   RemoveOldReports(now, &reports_);
   max_rtt_ms_ = GetMaxRttMs(&reports_);
   UpdateAvgRttMs(&reports_, &avg_rtt_ms_);
 
   // If there is a valid rtt, update all observers with the max rtt.
   // TODO(asapersson): Consider changing this to report the average rtt.
   if (max_rtt_ms_ > 0) {
     for (std::list<CallStatsObserver*>::iterator it = observers_.begin();
          it != observers_.end(); ++it) {
       (*it)->OnRttUpdate(avg_rtt_ms_, max_rtt_ms_);
     }
   }
   return 0;
 }
 
 int64_t CallStats::avg_rtt_ms() const {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&crit_);
   return avg_rtt_ms_;
 }
 
 RtcpRttStats* CallStats::rtcp_rtt_stats() const {
   return rtcp_rtt_stats_.get();
 }
 
 void CallStats::RegisterStatsObserver(CallStatsObserver* observer) {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&crit_);
   for (std::list<CallStatsObserver*>::iterator it = observers_.begin();
        it != observers_.end(); ++it) {
     if (*it == observer)
       return;
   }
   observers_.push_back(observer);
 }
 
 void CallStats::DeregisterStatsObserver(CallStatsObserver* observer) {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&crit_);
   for (std::list<CallStatsObserver*>::iterator it = observers_.begin();
        it != observers_.end(); ++it) {
     if (*it == observer) {
       observers_.erase(it);
       return;
     }
   }
 }
 
 void CallStats::OnRttUpdate(int64_t rtt) {
-  CriticalSectionScoped cs(crit_.get());
+  rtc::CritScope cs(&crit_);
   reports_.push_back(RttTime(rtt, clock_->TimeInMilliseconds()));
 }
 
 }  // namespace webrtc