Replace RefCountImpl with rtc::RefCountedObject.

webrtc/modules/audio_device/test/audio_device_test_api.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.
  */
 
@@ skipping 30 matching lines @@
 const char* GetFilename(const char* filename) {
   std::string full_path_filename = webrtc::test::OutputPath() + filename;
   return full_path_filename.c_str();
 }
 #endif
 
 using namespace webrtc;
 
 class AudioEventObserverAPI: public AudioDeviceObserver {
  public:
-  AudioEventObserverAPI(AudioDeviceModule* audioDevice)
+  AudioEventObserverAPI(
+      const rtc::scoped_refptr<AudioDeviceModule>& audioDevice)
       : error_(kRecordingError),
         warning_(kRecordingWarning),
-        audio_device_(audioDevice) {
-  }
+        audio_device_(audioDevice) {}
 
   ~AudioEventObserverAPI() {}
 
   virtual void OnErrorIsReported(const ErrorCode error) {
     TEST_LOG("\n[*** ERROR ***] => OnErrorIsReported(%d)\n\n", error);
     error_ = error;
   }
 
   virtual void OnWarningIsReported(const WarningCode warning) {
     TEST_LOG("\n[*** WARNING ***] => OnWarningIsReported(%d)\n\n", warning);
     warning_ = warning;
     EXPECT_EQ(0, audio_device_->StopRecording());
     EXPECT_EQ(0, audio_device_->StopPlayout());
   }
 
  public:
   ErrorCode error_;
   WarningCode warning_;
  private:
-  AudioDeviceModule* audio_device_;
+  rtc::scoped_refptr<AudioDeviceModule> audio_device_;
 };
 
 class AudioTransportAPI: public AudioTransport {
  public:
-  AudioTransportAPI(AudioDeviceModule* audioDevice)
+  AudioTransportAPI(const rtc::scoped_refptr<AudioDeviceModule>& audioDevice)
       : rec_count_(0),
         play_count_(0) {
   }
 
   ~AudioTransportAPI() {}
 
   int32_t RecordedDataIsAvailable(const void* audioSamples,
                                   const size_t nSamples,
                                   const size_t nBytesPerSample,
                                   const size_t nChannels,
@@ skipping 63 matching lines @@
     const int32_t kId = 444;
 
 #if defined(_WIN32)
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is defined!\n\n");
     // create default implementation (=Core Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
-    audio_device_->AddRef();
-    EXPECT_EQ(0, audio_device_->Release());
+    audio_device_.release();

[tommi, 2016/03/17 09:15:12]

ehm, yeah you'd think that .release() calls Release(), right? nope! :)
you either want this instead:
audio_device_ = nullptr;

or, if you want to maintain the previous check (which might be a better idea),
this:

EXPECT_EQ(0, audio_device_.release()->Release());

The explicit call to AddRef() that was here, will now be done implicitly during
assignment to audio_device_.

same below.

[pbos-webrtc, 2016/03/17 15:04:00]

done (as = nullptr)

     // create non-default (=Wave Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
-    audio_device_->AddRef();
-    EXPECT_EQ(0, audio_device_->Release());
+    audio_device_.release();
     // explicitly specify usage of Core Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) != NULL);
 #else
     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is *not* defined!\n");
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     // create default implementation (=Wave Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
-    audio_device_->AddRef();
-    EXPECT_EQ(0, audio_device_->Release());
+    audio_device_.release();
     // explicitly specify usage of Wave Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
 #endif
 #endif
 
 #if defined(ANDROID)
     // Fails tests
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
     // Create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 #elif defined(WEBRTC_LINUX)
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     // create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
-    audio_device_->AddRef();
     EXPECT_EQ(0, audio_device_->Terminate());
-    EXPECT_EQ(0, audio_device_->Release());
+    audio_device_.release();
     // explicitly specify usage of Pulse Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kLinuxPulseAudio)) != NULL);
 #endif
 
 #if defined(WEBRTC_MAC)
     // Fails tests
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
     // Create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 #endif
 
     if (audio_device_ == NULL) {
       FAIL() << "Failed creating audio device object!";
     }
 
-    // The ADM is reference counted.
-    audio_device_->AddRef();
-
     process_thread_->RegisterModule(audio_device_);
 
     AudioDeviceModule::AudioLayer audio_layer =
         AudioDeviceModule::kPlatformDefaultAudio;
     EXPECT_EQ(0, audio_device_->ActiveAudioLayer(&audio_layer));
     if (audio_layer == AudioDeviceModule::kLinuxAlsaAudio) {
       linux_alsa_ = true;
     }
   }
 
   static void TearDownTestCase() {
     if (process_thread_) {
       process_thread_->DeRegisterModule(audio_device_);
       process_thread_->Stop();
       process_thread_.reset();
     }
     if (event_observer_) {
       delete event_observer_;
       event_observer_ = NULL;
     }
     if (audio_transport_) {
       delete audio_transport_;
       audio_transport_ = NULL;
     }
-    if (audio_device_) {
-      EXPECT_EQ(0, audio_device_->Release());
-    }
+    audio_device_.release();
     PRINT_TEST_RESULTS;
   }
 
   void SetUp() {
     if (linux_alsa_) {
       FAIL() << "API Test is not available on ALSA on Linux!";
     }
     EXPECT_EQ(0, audio_device_->Init());
     EXPECT_TRUE(audio_device_->Initialized());
   }
@@ skipping 20 matching lines @@
 
   void CheckInitialRecordingStates() {
     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
     EXPECT_FALSE(audio_device_->Recording());
     EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
   }
 
   // TODO(henrika): Get rid of globals.
   static bool linux_alsa_;
   static std::unique_ptr<ProcessThread> process_thread_;
-  static AudioDeviceModule* audio_device_;
+  static rtc::scoped_refptr<AudioDeviceModule> audio_device_;
   static AudioTransportAPI* audio_transport_;
   static AudioEventObserverAPI* event_observer_;
 };
 
 // Must be initialized like this to handle static SetUpTestCase() above.
 bool AudioDeviceAPITest::linux_alsa_ = false;
 std::unique_ptr<ProcessThread> AudioDeviceAPITest::process_thread_;
-AudioDeviceModule* AudioDeviceAPITest::audio_device_ = NULL;
+rtc::scoped_refptr<AudioDeviceModule> AudioDeviceAPITest::audio_device_;
 AudioTransportAPI* AudioDeviceAPITest::audio_transport_ = NULL;
 AudioEventObserverAPI* AudioDeviceAPITest::event_observer_ = NULL;
 
 TEST_F(AudioDeviceAPITest, RegisterEventObserver) {
   event_observer_ = new AudioEventObserverAPI(audio_device_);
   EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
   EXPECT_EQ(0, audio_device_->RegisterEventObserver(event_observer_));
   EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
 }
 
@@ skipping 1481 matching lines @@
   // TODO(kjellander): Fix so these tests pass on Mac.
 #if !defined(WEBRTC_MAC)
   EXPECT_EQ(0, audio_device_->InitPlayout());
   EXPECT_EQ(0, audio_device_->StartPlayout());
 #endif
 
   EXPECT_EQ(-1, audio_device_->GetLoudspeakerStatus(&loudspeakerOn));
 #endif
   EXPECT_EQ(0, audio_device_->StopPlayout());
 }