Revert of "Create rtc::AtomicInt POD struct."

webrtc/modules/audio_device/ios/audio_device_ios.mm

 /*
  *  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.
  */
 
@@ skipping 10 matching lines @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_device/fine_audio_buffer.h"
 #include "webrtc/modules/utility/include/helpers_ios.h"
 
 namespace webrtc {
 
 // Protects |g_audio_session_users|.
-static rtc::GlobalLockPod g_lock = {{0}};
+static rtc::GlobalLockPod g_lock;
 
 // Counts number of users (=instances of this object) who needs an active
 // audio session. This variable is used to ensure that we only activate an audio
 // session for the first user and deactivate it for the last.
 // Member is static to ensure that the value is counted for all instances
 // and not per instance.
 static int g_audio_session_users GUARDED_BY(g_lock) = 0;
 
 #define LOGI() LOG(LS_INFO) << "AudioDeviceIOS::"
 
@@ skipping 239 matching lines @@
     LOG(LS_INFO) << " system version: " << ios::GetSystemVersion();
     LOG(LS_INFO) << " device type: " << ios::GetDeviceType();
     LOG(LS_INFO) << " device name: " << ios::GetDeviceName();
   }
 }
 #endif  // !defined(NDEBUG)
 
 AudioDeviceIOS::AudioDeviceIOS()
     : audio_device_buffer_(nullptr),
       vpio_unit_(nullptr),
-      recording_({0}),
-      playing_({0}),
+      recording_(0),
+      playing_(0),
       initialized_(false),
       rec_is_initialized_(false),
       play_is_initialized_(false),
       audio_interruption_observer_(nullptr),
       route_change_observer_(nullptr) {
   LOGI() << "ctor" << ios::GetCurrentThreadDescription();
 }
 
 AudioDeviceIOS::~AudioDeviceIOS() {
   LOGI() << "~dtor" << ios::GetCurrentThreadDescription();
@@ skipping 49 matching lines @@
     RTC_DCHECK_GE(g_audio_session_users, 0);
   }
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitPlayout() {
   LOGI() << "InitPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!play_is_initialized_);
-  RTC_DCHECK(!Playing());
+  RTC_DCHECK(!playing_);
   if (!rec_is_initialized_) {
     if (!InitPlayOrRecord()) {
       LOG_F(LS_ERROR) << "InitPlayOrRecord failed for InitPlayout!";
       return -1;
     }
   }
   play_is_initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitRecording() {
   LOGI() << "InitRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!rec_is_initialized_);
-  RTC_DCHECK(!Recording());
+  RTC_DCHECK(!recording_);
   if (!play_is_initialized_) {
     if (!InitPlayOrRecord()) {
       LOG_F(LS_ERROR) << "InitPlayOrRecord failed for InitRecording!";
       return -1;
     }
   }
   rec_is_initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::StartPlayout() {
   LOGI() << "StartPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(play_is_initialized_);
-  RTC_DCHECK(!Playing());
+  RTC_DCHECK(!playing_);
   fine_audio_buffer_->ResetPlayout();
-  if (!Recording()) {
+  if (!recording_) {
     OSStatus result = AudioOutputUnitStart(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioOutputUnitStart failed for StartPlayout: "
                       << result;
       return -1;
     }
     LOG(LS_INFO) << "Voice-Processing I/O audio unit is now started";
   }
-  rtc::AtomicInt::ReleaseStore(&playing_, 1);
+  rtc::AtomicOps::ReleaseStore(&playing_, 1);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StopPlayout() {
   LOGI() << "StopPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!play_is_initialized_ || !Playing()) {
+  if (!play_is_initialized_ || !playing_) {
     return 0;
   }
-  if (!Recording()) {
+  if (!recording_) {
     ShutdownPlayOrRecord();
   }
   play_is_initialized_ = false;
-  rtc::AtomicInt::ReleaseStore(&playing_, 0);
+  rtc::AtomicOps::ReleaseStore(&playing_, 0);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StartRecording() {
   LOGI() << "StartRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(rec_is_initialized_);
-  RTC_DCHECK(!Recording());
+  RTC_DCHECK(!recording_);
   fine_audio_buffer_->ResetRecord();
-  if (!Playing()) {
+  if (!playing_) {
     OSStatus result = AudioOutputUnitStart(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioOutputUnitStart failed for StartRecording: "
                       << result;
       return -1;
     }
     LOG(LS_INFO) << "Voice-Processing I/O audio unit is now started";
   }
-  rtc::AtomicInt::ReleaseStore(&recording_, 1);
+  rtc::AtomicOps::ReleaseStore(&recording_, 1);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StopRecording() {
   LOGI() << "StopRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!rec_is_initialized_ || !Recording()) {
+  if (!rec_is_initialized_ || !recording_) {
     return 0;
   }
-  if (!Playing()) {
+  if (!playing_) {
     ShutdownPlayOrRecord();
   }
   rec_is_initialized_ = false;
-  rtc::AtomicInt::ReleaseStore(&recording_, 0);
+  rtc::AtomicOps::ReleaseStore(&recording_, 0);
   return 0;
 }
 
 // Change the default receiver playout route to speaker.
 int32_t AudioDeviceIOS::SetLoudspeakerStatus(bool enable) {
   LOGI() << "SetLoudspeakerStatus(" << enable << ")";
 
   AVAudioSession* session = [AVAudioSession sharedInstance];
   NSString* category = session.category;
   AVAudioSessionCategoryOptions options = session.categoryOptions;
@@ skipping 559 matching lines @@
       io_action_flags, in_time_stamp, in_bus_number, in_number_frames);
 }
 
 OSStatus AudioDeviceIOS::OnRecordedDataIsAvailable(
     AudioUnitRenderActionFlags* io_action_flags,
     const AudioTimeStamp* in_time_stamp,
     UInt32 in_bus_number,
     UInt32 in_number_frames) {
   OSStatus result = noErr;
   // Simply return if recording is not enabled.
-  if (!Recording())
+  if (!rtc::AtomicOps::AcquireLoad(&recording_))
     return result;
   if (in_number_frames != record_parameters_.frames_per_buffer()) {
     // We have seen short bursts (1-2 frames) where |in_number_frames| changes.
     // Add a log to keep track of longer sequences if that should ever happen.
     LOG(LS_WARNING) << "in_number_frames (" << in_number_frames
                     << ") != " << record_parameters_.frames_per_buffer();
   }
   // Obtain the recorded audio samples by initiating a rendering cycle.
   // Since it happens on the input bus, the |io_data| parameter is a reference
   // to the preallocated audio buffer list that the audio unit renders into.
@@ skipping 38 matching lines @@
   // Verify 16-bit, noninterleaved mono PCM signal format.
   RTC_DCHECK_EQ(1u, io_data->mNumberBuffers);
   RTC_DCHECK_EQ(1u, io_data->mBuffers[0].mNumberChannels);
   // Get pointer to internal audio buffer to which new audio data shall be
   // written.
   const UInt32 dataSizeInBytes = io_data->mBuffers[0].mDataByteSize;
   RTC_CHECK_EQ(dataSizeInBytes / kBytesPerSample, in_number_frames);
   SInt8* destination = static_cast<SInt8*>(io_data->mBuffers[0].mData);
   // Produce silence and give audio unit a hint about it if playout is not
   // activated.
-  if (!Playing()) {
+  if (!rtc::AtomicOps::AcquireLoad(&playing_)) {
     *io_action_flags |= kAudioUnitRenderAction_OutputIsSilence;
     memset(destination, 0, dataSizeInBytes);
     return noErr;
   }
   // Read decoded 16-bit PCM samples from WebRTC (using a size that matches
   // the native I/O audio unit) to a preallocated intermediate buffer and
   // copy the result to the audio buffer in the |io_data| destination.
   SInt8* source = playout_audio_buffer_.get();
   fine_audio_buffer_->GetPlayoutData(source);
   memcpy(destination, source, dataSizeInBytes);
   return noErr;
 }
 
 }  // namespace webrtc