Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "chromecast/media/cma/backend/alsa/mock_alsa_wrapper.h"
 #include "media/base/audio_bus.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
@@ skipping 85 matching lines @@
     -850779335,   1666492408,
      1290349909, -492418001,
      659200170,  -542374913,
     -120005682,   1030923147,
     -877887021,  -870241979,
      1322678128, -344799975,
   }
 };
 
 // Return a scoped pointer filled with the data laid out at |index| above.
-scoped_ptr<::media::AudioBus> GetTestData(size_t index) {
+std::unique_ptr<::media::AudioBus> GetTestData(size_t index) {
   CHECK_LT(index, NUM_DATA_SETS);
   int frames = NUM_SAMPLES / kNumChannels;
   auto data = ::media::AudioBus::Create(kNumChannels, frames);
   data->FromInterleaved(kTestData[index], frames, kBytesPerSample);
   return data;
 }
 
 class MockInputQueue : public StreamMixerAlsa::InputQueue {
  public:
   explicit MockInputQueue(int samples_per_second)
@@ skipping 24 matching lines @@
   MOCK_METHOD2(GetResampledData, void(::media::AudioBus* dest, int frames));
   MOCK_METHOD1(AfterWriteFrames,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
   MOCK_METHOD0(SignalError, void());
   MOCK_METHOD1(PrepareToDelete, void(const OnReadyToDeleteCb& delete_cb));
 
   // Setters and getters for test control.
   void SetPaused(bool paused) { paused_ = paused; }
   void SetMaxReadSize(int max_read_size) { max_read_size_ = max_read_size; }
-  void SetData(scoped_ptr<::media::AudioBus> data) {
+  void SetData(std::unique_ptr<::media::AudioBus> data) {
     CHECK(!data_);
     data_ = std::move(data);
     max_read_size_ = data_->frames();
   }
   void SetVolumeMultiplier(float multiplier) {
     CHECK(multiplier >= 0.0 && multiplier <= 1.0);
     multiplier_ = multiplier;
   }
   void SetPrimary(bool primary) { primary_ = primary; }
   const ::media::AudioBus& data() {
@@ skipping 17 matching lines @@
     deleting_ = true;
     delete_cb.Run(this);
   }
 
   bool paused_;
   int samples_per_second_;
   int max_read_size_;
   float multiplier_;
   bool primary_;
   bool deleting_;
-  scoped_ptr<::media::AudioBus> data_;
+  std::unique_ptr<::media::AudioBus> data_;
 
   DISALLOW_COPY_AND_ASSIGN(MockInputQueue);
 };
 
 // Given |inputs|, returns mixed audio data according to the mixing method used
 // by the mixer.
-scoped_ptr<::media::AudioBus> GetMixedAudioData(
+std::unique_ptr<::media::AudioBus> GetMixedAudioData(
     const std::vector<testing::StrictMock<MockInputQueue>*>& inputs) {
   int read_size = std::numeric_limits<int>::max();
   for (const auto input : inputs) {
     CHECK(input);
     read_size = std::min(input->MaxReadSize(), read_size);
   }
 
   // Verify all inputs are the right size.
   for (const auto input : inputs) {
     CHECK_EQ(kNumChannels, input->data().channels());
@@ skipping 14 matching lines @@
 
       // Clamp the mixed sample between 1.0 and -1.0.
       *result = std::min(1.0f, std::max(-1.0f, *result));
     }
   }
   return mixed;
 }
 
 // Like the method above, but accepts a single input. This returns an AudioBus
 // with this input after it is scaled and clipped.
-scoped_ptr<::media::AudioBus> GetMixedAudioData(
+std::unique_ptr<::media::AudioBus> GetMixedAudioData(
     testing::StrictMock<MockInputQueue>* input) {
   return GetMixedAudioData(
       std::vector<testing::StrictMock<MockInputQueue>*>(1, input));
 }
 
 // Asserts that |expected| matches |actual| exactly.
 void CompareAudioData(const ::media::AudioBus& expected,
                       const ::media::AudioBus& actual) {
   ASSERT_EQ(expected.channels(), actual.channels());
   ASSERT_EQ(expected.frames(), actual.frames());
   for (int c = 0; c < expected.channels(); ++c) {
     const float* expected_data = expected.channel(c);
     const float* actual_data = actual.channel(c);
     for (int f = 0; f < expected.frames(); ++f)
       ASSERT_FLOAT_EQ(*expected_data++, *actual_data++) << c << " " << f;
   }
 }
 
 }  // namespace
 
 class StreamMixerAlsaTest : public testing::Test {
  protected:
   StreamMixerAlsaTest()
       : message_loop_(new base::MessageLoop()),
         mock_alsa_(new testing::NiceMock<MockAlsaWrapper>()) {
     StreamMixerAlsa::MakeSingleThreadedForTest();
-    StreamMixerAlsa::Get()->SetAlsaWrapperForTest(make_scoped_ptr(mock_alsa_));
+    StreamMixerAlsa::Get()->SetAlsaWrapperForTest(base::WrapUnique(mock_alsa_));
   }
 
   ~StreamMixerAlsaTest() override {
     StreamMixerAlsa::Get()->ClearInputsForTest();
   }
 
   MockAlsaWrapper* mock_alsa() { return mock_alsa_; }
 
  private:
-  const scoped_ptr<base::MessageLoop> message_loop_;
+  const std::unique_ptr<base::MessageLoop> message_loop_;
   testing::NiceMock<MockAlsaWrapper>* mock_alsa_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamMixerAlsaTest);
 };
 
 TEST_F(StreamMixerAlsaTest, AddSingleInput) {
   auto input = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
 
   EXPECT_CALL(*input, Initialize(_)).Times(1);
-  mixer->AddInput(make_scoped_ptr(input));
+  mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 }
 
 TEST_F(StreamMixerAlsaTest, AddMultipleInputs) {
   auto input1 = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
   auto input2 =
       new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond * 2);
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
 
   EXPECT_CALL(*input1, Initialize(_)).Times(1);
   EXPECT_CALL(*input2, Initialize(_)).Times(1);
-  mixer->AddInput(make_scoped_ptr(input1));
-  mixer->AddInput(make_scoped_ptr(input2));
+  mixer->AddInput(base::WrapUnique(input1));
+  mixer->AddInput(base::WrapUnique(input2));
 
   // The mixer should be ready to play, and should sample to the initial
   // sample rate.
   EXPECT_EQ(kTestSamplesPerSecond, mixer->output_samples_per_second());
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 }
 
 TEST_F(StreamMixerAlsaTest, RemoveInput) {
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 3;
   for (int i = 0; i < kNumInputs; ++i) {
     inputs.push_back(new testing::StrictMock<MockInputQueue>(
         kTestSamplesPerSecond * (i + 1)));
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
-    mixer->AddInput(make_scoped_ptr(inputs[i]));
+    mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], PrepareToDelete(_)).Times(1);
     mixer->RemoveInput(inputs[i]);
   }
 
   // Need to wait for the removal task (it is always posted).
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(mixer->empty());
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 }
 
 TEST_F(StreamMixerAlsaTest, WriteFrames) {
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 3;
   for (int i = 0; i < kNumInputs; ++i) {
     inputs.push_back(
         new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond));
     inputs.back()->SetPaused(false);
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
-    mixer->AddInput(make_scoped_ptr(inputs[i]));
+    mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   ASSERT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // The mixer should pull data from all streams, using the smallest
   // MaxReadSize provided by any of the channels.
   // TODO(slan): Check that the proper number of frames is pulled.
   ASSERT_EQ(3u, inputs.size());
   inputs[0]->SetMaxReadSize(1024);
   inputs[1]->SetMaxReadSize(512);
@@ skipping 28 matching lines @@
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, _)).Times(0);
   mixer->WriteFramesForTest();
 }
 
 TEST_F(StreamMixerAlsaTest, OneStreamMixesProperly) {
   auto input = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
   input->SetPaused(false);
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   EXPECT_CALL(*input, Initialize(_)).Times(1);
-  mixer->AddInput(make_scoped_ptr(input));
+  mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // Populate the stream with data.
   const int kNumFrames = 32;
   input->SetData(GetTestData(0));
 
   ASSERT_EQ(mock_alsa()->data().size(), 0u);
 
   // Write the stream to ALSA.
   EXPECT_CALL(*input, GetResampledData(_, kNumFrames));
   EXPECT_CALL(*input, AfterWriteFrames(_));
   mixer->WriteFramesForTest();
 
   // Get the actual stream rendered to ALSA, and compare it against the
   // expected stream. The stream should match exactly.
   auto actual = ::media::AudioBus::Create(kNumChannels, kNumFrames);
   ASSERT_GT(mock_alsa()->data().size(), 0u);
   actual->FromInterleaved(
       &(mock_alsa()->data()[0]), kNumFrames, kBytesPerSample);
   CompareAudioData(input->data(), *actual);
 }
 
 TEST_F(StreamMixerAlsaTest, OneStreamIsScaledDownProperly) {
   auto input = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
   input->SetPaused(false);
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   EXPECT_CALL(*input, Initialize(_)).Times(1);
-  mixer->AddInput(make_scoped_ptr(input));
+  mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // Populate the stream with data.
   const int kNumFrames = 32;
   ASSERT_EQ(sizeof(kTestData[0]), kNumChannels * kNumFrames * kBytesPerSample);
   auto data = GetTestData(0);
   input->SetData(std::move(data));
 
   // Set a volume multiplier on the stream.
   input->SetVolumeMultiplier(0.75);
@@ skipping 17 matching lines @@
   const int kNumInputs = 2;
   for (int i = 0; i < kNumInputs; ++i) {
     inputs.push_back(
         new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond));
     inputs.back()->SetPaused(false);
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
-    mixer->AddInput(make_scoped_ptr(inputs[i]));
+    mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   // Poll the inputs for data.
   const int kNumFrames = 32;
   for (size_t i = 0; i < inputs.size(); ++i) {
     inputs[i]->SetData(GetTestData(i));
     EXPECT_CALL(*inputs[i], GetResampledData(_, kNumFrames));
     EXPECT_CALL(*inputs[i], AfterWriteFrames(_));
   }
 
@@ skipping 17 matching lines @@
   const int kNumInputs = 2;
   for (int i = 0; i < kNumInputs; ++i) {
     inputs.push_back(
         new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond));
     inputs.back()->SetPaused(false);
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
-    mixer->AddInput(make_scoped_ptr(inputs[i]));
+    mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   // Create edge case data for the inputs. By mixing these two short streams,
   // every combination of {-(2^31), 0, 2^31-1} is tested. This test case is
   // intended to be a hand-checkable gut check.
   // Note: Test data should be represented as 32-bit integers and copied into
   // ::media::AudioBus instances, rather than wrapping statically declared float
   // arrays. The latter method is brittle, as ::media::AudioBus requires 16-bit
   // alignment for internal data.
   const int kNumFrames = 3;
@@ skipping 45 matching lines @@
       &(mock_alsa()->data()[0]), kNumFrames, kBytesPerSample);
   CompareAudioData(*expected, *actual);
 }
 
 TEST_F(StreamMixerAlsaTest, WriteBuffersOfVaryingLength) {
   auto input = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
   input->SetPaused(false);
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   EXPECT_CALL(*input, Initialize(_)).Times(1);
-  mixer->AddInput(make_scoped_ptr(input));
+  mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // The input stream will provide buffers of several different lengths.
   input->SetMaxReadSize(7);
   EXPECT_CALL(*input, GetResampledData(_, 7));
   EXPECT_CALL(*input, AfterWriteFrames(_));
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 7)).Times(1);
   mixer->WriteFramesForTest();
 
   input->SetMaxReadSize(100);
@@ skipping 10 matching lines @@
 
   input->SetMaxReadSize(1024);
   EXPECT_CALL(*input, GetResampledData(_, 1024));
   EXPECT_CALL(*input, AfterWriteFrames(_));
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 1024)).Times(1);
   mixer->WriteFramesForTest();
 }
 
 }  // namespace media
 }  // namespace chromecast