Replace scoped_ptr with unique_ptr in webrtc/modules/audio_device/

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 <memory>
 #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/format_macros.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/include/clock.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
@@ skipping 103 matching lines @@
     return static_cast<int>(
         file_size_in_bytes_ / (kBytesPerSample * sample_rate_));
   }
   size_t file_size_in_callbacks() const {
     return file_size_in_seconds() * kNumCallbacksPerSecond;
   }
 
  private:
   size_t file_size_in_bytes_;
   int sample_rate_;
-  rtc::scoped_ptr<int16_t[]> file_;
+  std::unique_ptr<int16_t[]> file_;
   size_t file_pos_;
 };
 
 // Simple first in first out (FIFO) class that wraps a list of 16-bit audio
 // buffers of fixed size and allows Write and Read operations. The idea is to
 // store recorded audio buffers (using Write) and then read (using Read) these
 // stored buffers with as short delay as possible when the audio layer needs
 // data to play out. The number of buffers in the FIFO will stabilize under
 // normal conditions since there will be a balance between Write and Read calls.
 // The container is a std::list container and access is protected with a lock
@@ skipping 74 matching lines @@
     for (auto it = fifo_->begin(); it != fifo_->end(); ++it) {
       delete *it;
     }
     fifo_->clear();
   }
 
   using AudioBufferList = std::list<int16_t*>;
   rtc::CriticalSection lock_;
   const size_t frames_per_buffer_;
   const size_t bytes_per_buffer_;
-  rtc::scoped_ptr<AudioBufferList> fifo_;
+  std::unique_ptr<AudioBufferList> fifo_;
   size_t largest_size_;
   size_t total_written_elements_;
   size_t write_count_;
 };
 
 // Inserts periodic impulses and measures the latency between the time of
 // transmission and time of receiving the same impulse.
 // Usage requires a special hardware called Audio Loopback Dongle.
 // See http://source.android.com/devices/audio/loopback.html for details.
 class LatencyMeasuringAudioStream : public AudioStreamInterface {
@@ skipping 231 matching lines @@
   bool play_mode() const { return type_ & kPlayout; }
   bool rec_mode() const { return type_ & kRecording; }
 
  private:
   EventWrapper* test_is_done_;
   size_t num_callbacks_;
   int type_;
   size_t play_count_;
   size_t rec_count_;
   AudioStreamInterface* audio_stream_;
-  rtc::scoped_ptr<LatencyMeasuringAudioStream> latency_audio_stream_;
+  std::unique_ptr<LatencyMeasuringAudioStream> latency_audio_stream_;
 };
 
 // AudioDeviceTest test fixture.
 class AudioDeviceTest : public ::testing::Test {
  protected:
   AudioDeviceTest()
       : test_is_done_(EventWrapper::Create()) {
     // One-time initialization of JVM and application context. Ensures that we
     // can do calls between C++ and Java. Initializes both Java and OpenSL ES
     // implementations.
@@ skipping 176 matching lines @@
     EXPECT_EQ(0, audio_device()->MinSpeakerVolume(&min_volume));
     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_;
+  std::unique_ptr<EventWrapper> test_is_done_;
   rtc::scoped_refptr<AudioDeviceModule> audio_device_;
   AudioParameters playout_parameters_;
   AudioParameters record_parameters_;
-  rtc::scoped_ptr<BuildInfo> build_info_;
+  std::unique_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
 // ADM will then internally set the best suitable combination of audio layers,
 // for input and output based on if low-latency output audio in combination
 // with OpenSL ES is supported or not. This test ensures that the correct
@@ skipping 222 matching lines @@
 
 // Start playout and read audio from an external PCM file when the audio layer
 // asks for data to play out. Real audio is played out in this test but it does
 // not contain any explicit verification that the audio quality is perfect.
 TEST_F(AudioDeviceTest, RunPlayoutWithFileAsSource) {
   // TODO(henrika): extend test when mono output is supported.
   EXPECT_EQ(1u, playout_channels());
   NiceMock<MockAudioTransport> mock(kPlayout);
   const int num_callbacks = kFilePlayTimeInSec * kNumCallbacksPerSecond;
   std::string file_name = GetFileName(playout_sample_rate());
-  rtc::scoped_ptr<FileAudioStream> file_audio_stream(
+  std::unique_ptr<FileAudioStream> file_audio_stream(
       new FileAudioStream(num_callbacks, file_name, playout_sample_rate()));
   mock.HandleCallbacks(test_is_done_.get(),
                        file_audio_stream.get(),
                        num_callbacks);
   // SetMaxPlayoutVolume();
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartPlayout();
   test_is_done_->Wait(kTestTimeOutInMilliseconds);
   StopPlayout();
 }
 
 // Start playout and recording and store recorded data in an intermediate FIFO
 // buffer from which the playout side then reads its samples in the same order
 // as they were stored. Under ideal circumstances, a callback sequence would
 // look like: ...+-+-+-+-+-+-+-..., where '+' means 'packet recorded' and '-'
 // means 'packet played'. Under such conditions, the FIFO would only contain
 // one packet on average. However, under more realistic conditions, the size
 // of the FIFO will vary more due to an unbalance between the two sides.
 // This test tries to verify that the device maintains a balanced callback-
 // sequence by running in loopback for ten seconds while measuring the size
 // (max and average) of the FIFO. The size of the FIFO is increased by the
 // recording side and decreased by the playout side.
 // TODO(henrika): tune the final test parameters after running tests on several
 // different devices.
 TEST_F(AudioDeviceTest, RunPlayoutAndRecordingInFullDuplex) {
   EXPECT_EQ(record_channels(), playout_channels());
   EXPECT_EQ(record_sample_rate(), playout_sample_rate());
   NiceMock<MockAudioTransport> mock(kPlayout | kRecording);
-  rtc::scoped_ptr<FifoAudioStream> fifo_audio_stream(
+  std::unique_ptr<FifoAudioStream> fifo_audio_stream(
       new FifoAudioStream(playout_frames_per_10ms_buffer()));
   mock.HandleCallbacks(test_is_done_.get(),
                        fifo_audio_stream.get(),
                        kFullDuplexTimeInSec * kNumCallbacksPerSecond);
   SetMaxPlayoutVolume();
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(std::max(kTestTimeOutInMilliseconds,
                                1000 * kFullDuplexTimeInSec));
   StopPlayout();
   StopRecording();
   EXPECT_LE(fifo_audio_stream->average_size(), 10u);
   EXPECT_LE(fifo_audio_stream->largest_size(), 20u);
 }
 
 // Measures loopback latency and reports the min, max and average values for
 // a full duplex audio session.
 // The latency is measured like so:
 // - Insert impulses periodically on the output side.
 // - Detect the impulses on the input side.
 // - Measure the time difference between the transmit time and receive time.
 // - Store time differences in a vector and calculate min, max and average.
 // This test requires a special hardware called Audio Loopback Dongle.
 // See http://source.android.com/devices/audio/loopback.html for details.
 TEST_F(AudioDeviceTest, DISABLED_MeasureLoopbackLatency) {
   EXPECT_EQ(record_channels(), playout_channels());
   EXPECT_EQ(record_sample_rate(), playout_sample_rate());
   NiceMock<MockAudioTransport> mock(kPlayout | kRecording);
-  rtc::scoped_ptr<LatencyMeasuringAudioStream> latency_audio_stream(
+  std::unique_ptr<LatencyMeasuringAudioStream> latency_audio_stream(
       new LatencyMeasuringAudioStream(playout_frames_per_10ms_buffer()));
   mock.HandleCallbacks(test_is_done_.get(),
                        latency_audio_stream.get(),
                        kMeasureLatencyTimeInSec * kNumCallbacksPerSecond);
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   SetMaxPlayoutVolume();
   DisableBuiltInAECIfAvailable();
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(std::max(kTestTimeOutInMilliseconds,
                                1000 * kMeasureLatencyTimeInSec));
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
             static_cast<size_t>(
                 kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1));
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc