Use one scoped_refptr.

webrtc/modules/audio_device/android/audio_device_unittest.cc

 /*
  *  Copyright (c) 2015 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 <algorithm>
 #include <limits>
 #include <list>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/modules/audio_device/android/audio_common.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/android/build_info.h"
 #include "webrtc/modules/audio_device/android/ensure_initialized.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/system_wrappers/interface/event_wrapper.h"
-#include "webrtc/system_wrappers/interface/scoped_refptr.h"
 #include "webrtc/system_wrappers/interface/sleep.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using std::cout;
 using std::endl;
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::Gt;
 using ::testing::Invoke;
 using ::testing::NiceMock;
@@ skipping 487 matching lines @@
     return playout_parameters_.frames_per_10ms_buffer();
   }
   int record_frames_per_10ms_buffer() const {
     return record_parameters_.frames_per_10ms_buffer();
   }
 
   int total_delay_ms() const {
     return audio_manager()->GetDelayEstimateInMilliseconds();
   }
 
-  scoped_refptr<AudioDeviceModule> audio_device() const {
+  rtc::scoped_refptr<AudioDeviceModule> audio_device() const {
     return audio_device_;
   }
 
   AudioDeviceModuleImpl* audio_device_impl() const {
     return static_cast<AudioDeviceModuleImpl*>(audio_device_.get());
   }
 
   AudioManager* audio_manager() const {
     return audio_device_impl()->GetAndroidAudioManagerForTest();
   }
 
   AudioManager* GetAudioManager(AudioDeviceModule* adm) const {
     return static_cast<AudioDeviceModuleImpl*>(adm)->
         GetAndroidAudioManagerForTest();
   }
 
   AudioDeviceBuffer* audio_device_buffer() const {
     return audio_device_impl()->GetAudioDeviceBuffer();
   }
 
-  scoped_refptr<AudioDeviceModule> CreateAudioDevice(
+  rtc::scoped_refptr<AudioDeviceModule> CreateAudioDevice(
       AudioDeviceModule::AudioLayer audio_layer) {
-    scoped_refptr<AudioDeviceModule> module(
+    rtc::scoped_refptr<AudioDeviceModule> module(
         AudioDeviceModuleImpl::Create(0, audio_layer));
     return module;
   }
 
   // Returns file name relative to the resource root given a sample rate.
   std::string GetFileName(int sample_rate) {
     EXPECT_TRUE(sample_rate == 48000 || sample_rate == 44100);
     char fname[64];
     snprintf(fname,
              sizeof(fname),
@@ skipping 14 matching lines @@
   }
 
   AudioDeviceModule::AudioLayer GetActiveAudioLayer() const {
     AudioDeviceModule::AudioLayer audio_layer;
     EXPECT_EQ(0, audio_device()->ActiveAudioLayer(&audio_layer));
     return audio_layer;
   }
 
   int TestDelayOnAudioLayer(
       const AudioDeviceModule::AudioLayer& layer_to_test) {
-    scoped_refptr<AudioDeviceModule> audio_device;
+    rtc::scoped_refptr<AudioDeviceModule> audio_device;
     audio_device = CreateAudioDevice(layer_to_test);
     EXPECT_NE(audio_device.get(), nullptr);
     AudioManager* audio_manager = GetAudioManager(audio_device.get());
     EXPECT_NE(audio_manager, nullptr);
     return audio_manager->GetDelayEstimateInMilliseconds();
   }
 
   AudioDeviceModule::AudioLayer TestActiveAudioLayer(
       const AudioDeviceModule::AudioLayer& layer_to_test) {
-    scoped_refptr<AudioDeviceModule> audio_device;
+    rtc::scoped_refptr<AudioDeviceModule> audio_device;
     audio_device = CreateAudioDevice(layer_to_test);
     EXPECT_NE(audio_device.get(), nullptr);
     AudioDeviceModule::AudioLayer active;
     EXPECT_EQ(0, audio_device->ActiveAudioLayer(&active));
     return active;
   }
 
   bool DisableTestForThisDevice(const std::string& model) {
     return (build_info_->GetDeviceModel() == model);
   }
@@ skipping 60 matching lines @@
     return min_volume;
   }
 
   int GetSpeakerVolume() const {
     uint32_t volume(0);
     EXPECT_EQ(0, audio_device()->SpeakerVolume(&volume));
     return volume;
   }
 
   rtc::scoped_ptr<EventWrapper> test_is_done_;
-  scoped_refptr<AudioDeviceModule> audio_device_;
+  rtc::scoped_refptr<AudioDeviceModule> audio_device_;
   AudioParameters playout_parameters_;
   AudioParameters record_parameters_;
   rtc::scoped_ptr<BuildInfo> build_info_;
 };
 
 TEST_F(AudioDeviceTest, ConstructDestruct) {
   // Using the test fixture to create and destruct the audio device module.
 }
 
 // We always ask for a default audio layer when the ADM is constructed. But the
@@ skipping 299 matching lines @@
                                1000 * kMeasureLatencyTimeInSec));
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
             kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1);
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc