Replace scoped_ptr with std::unique_ptr in //media/base.

media/base/audio_bus_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
+#include <memory>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "media/base/fake_audio_render_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 85 matching lines @@
   }
 
  protected:
   std::vector<float*> data_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioBusTest);
 };
 
 // Verify basic Create(...) method works as advertised.
 TEST_F(AudioBusTest, Create) {
-  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
   VerifyParams(bus.get());
   VerifyChannelData(bus.get());
 }
 
 // Verify Create(...) using AudioParameters works as advertised.
 TEST_F(AudioBusTest, CreateUsingAudioParameters) {
-  scoped_ptr<AudioBus> bus = AudioBus::Create(AudioParameters(
-      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate, 32,
-      kFrameCount));
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(
+      AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
+                      kSampleRate, 32, kFrameCount));
   VerifyParams(bus.get());
   VerifyChannelData(bus.get());
 }
 
 // Verify an AudioBus created via wrapping a vector works as advertised.
 TEST_F(AudioBusTest, WrapVector) {
   data_.reserve(kChannels);
   for (int i = 0; i < kChannels; ++i) {
     data_.push_back(static_cast<float*>(base::AlignedAlloc(
         sizeof(*data_[i]) * kFrameCount, AudioBus::kChannelAlignment)));
   }
 
-  scoped_ptr<AudioBus> bus = AudioBus::WrapVector(kFrameCount, data_);
+  std::unique_ptr<AudioBus> bus = AudioBus::WrapVector(kFrameCount, data_);
   VerifyParams(bus.get());
   VerifyChannelData(bus.get());
 }
 
 // Verify an AudioBus created via wrapping a memory block works as advertised.
 TEST_F(AudioBusTest, WrapMemory) {
   AudioParameters params(
       AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate, 32,
       kFrameCount);
   int data_size = AudioBus::CalculateMemorySize(params);
-  scoped_ptr<float, base::AlignedFreeDeleter> data(static_cast<float*>(
+  std::unique_ptr<float, base::AlignedFreeDeleter> data(static_cast<float*>(
       base::AlignedAlloc(data_size, AudioBus::kChannelAlignment)));
 
   // Fill the memory with a test value we can check for after wrapping.
   static const float kTestValue = 3;
   std::fill(
       data.get(), data.get() + data_size / sizeof(*data.get()), kTestValue);
 
-  scoped_ptr<AudioBus> bus = AudioBus::WrapMemory(params, data.get());
+  std::unique_ptr<AudioBus> bus = AudioBus::WrapMemory(params, data.get());
   // Verify the test value we filled prior to wrapping.
   for (int i = 0; i < bus->channels(); ++i)
     VerifyValue(bus->channel(i), bus->frames(), kTestValue);
   VerifyParams(bus.get());
   VerifyChannelData(bus.get());
 
   // Verify the channel vectors lie within the provided memory block.
   EXPECT_GE(bus->channel(0), data.get());
   EXPECT_LT(bus->channel(bus->channels() - 1) + bus->frames(),
             data.get() + data_size / sizeof(*data.get()));
 }
 
 // Simulate a shared memory transfer and verify results.
 TEST_F(AudioBusTest, CopyTo) {
   // Create one bus with AudioParameters and the other through direct values to
   // test for parity between the Create() functions.
   AudioParameters params(
       AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate, 32,
       kFrameCount);
-  scoped_ptr<AudioBus> bus1 = AudioBus::Create(kChannels, kFrameCount);
-  scoped_ptr<AudioBus> bus2 = AudioBus::Create(params);
+  std::unique_ptr<AudioBus> bus1 = AudioBus::Create(kChannels, kFrameCount);
+  std::unique_ptr<AudioBus> bus2 = AudioBus::Create(params);
 
   {
     SCOPED_TRACE("Created");
     CopyTest(bus1.get(), bus2.get());
   }
   {
     SCOPED_TRACE("Wrapped Vector");
     // Try a copy to an AudioBus wrapping a vector.
     data_.reserve(kChannels);
     for (int i = 0; i < kChannels; ++i) {
       data_.push_back(static_cast<float*>(base::AlignedAlloc(
           sizeof(*data_[i]) * kFrameCount, AudioBus::kChannelAlignment)));
     }
 
     bus2 = AudioBus::WrapVector(kFrameCount, data_);
     CopyTest(bus1.get(), bus2.get());
   }
   {
     SCOPED_TRACE("Wrapped Memory");
     // Try a copy to an AudioBus wrapping a memory block.
-    scoped_ptr<float, base::AlignedFreeDeleter> data(
-        static_cast<float*>(base::AlignedAlloc(
-            AudioBus::CalculateMemorySize(params),
-            AudioBus::kChannelAlignment)));
+    std::unique_ptr<float, base::AlignedFreeDeleter> data(static_cast<float*>(
+        base::AlignedAlloc(AudioBus::CalculateMemorySize(params),
+                           AudioBus::kChannelAlignment)));
 
     bus2 = AudioBus::WrapMemory(params, data.get());
     CopyTest(bus1.get(), bus2.get());
   }
 }
 
 // Verify Zero() and ZeroFrames(...) utility methods work as advertised.
 TEST_F(AudioBusTest, Zero) {
-  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
 
   // Fill the bus with dummy data.
   for (int i = 0; i < bus->channels(); ++i)
     std::fill(bus->channel(i), bus->channel(i) + bus->frames(), i + 1);
   EXPECT_FALSE(bus->AreFramesZero());
 
   // Zero first half the frames of each channel.
   bus->ZeroFrames(kFrameCount / 2);
   for (int i = 0; i < bus->channels(); ++i) {
     SCOPED_TRACE("First Half Zero");
@@ skipping 46 matching lines @@
     INT32_MIN / 2, 0, INT32_MAX, 0,         0};
 
 // Expected results.
 static const int kTestVectorFrames = kTestVectorSize / 2;
 static const float kTestVectorResult[][kTestVectorFrames] = {
     { -1, 1, 0.5, 0, 0 }, { 0, -1, -0.5, 1, 0 }};
 static const int kTestVectorChannels = arraysize(kTestVectorResult);
 
 // Verify FromInterleaved() deinterleaves audio in supported formats correctly.
 TEST_F(AudioBusTest, FromInterleaved) {
-  scoped_ptr<AudioBus> bus = AudioBus::Create(
-      kTestVectorChannels, kTestVectorFrames);
-  scoped_ptr<AudioBus> expected = AudioBus::Create(
-      kTestVectorChannels, kTestVectorFrames);
+  std::unique_ptr<AudioBus> bus =
+      AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
+  std::unique_ptr<AudioBus> expected =
+      AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
   for (int ch = 0; ch < kTestVectorChannels; ++ch) {
     memcpy(expected->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*expected->channel(ch)));
   }
   {
     SCOPED_TRACE("uint8_t");
     bus->Zero();
     bus->FromInterleaved(
         kTestVectorUint8, kTestVectorFrames, sizeof(*kTestVectorUint8));
     // Biased uint8_t calculations have poor precision, so the epsilon here is
@@ skipping 19 matching lines @@
   }
 }
 
 // Verify FromInterleavedPartial() deinterleaves audio correctly.
 TEST_F(AudioBusTest, FromInterleavedPartial) {
   // Only deinterleave the middle two frames in each channel.
   static const int kPartialStart = 1;
   static const int kPartialFrames = 2;
   ASSERT_LE(kPartialStart + kPartialFrames, kTestVectorFrames);
 
-  scoped_ptr<AudioBus> bus = AudioBus::Create(
-      kTestVectorChannels, kTestVectorFrames);
-  scoped_ptr<AudioBus> expected = AudioBus::Create(
-      kTestVectorChannels, kTestVectorFrames);
+  std::unique_ptr<AudioBus> bus =
+      AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
+  std::unique_ptr<AudioBus> expected =
+      AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
   expected->Zero();
   for (int ch = 0; ch < kTestVectorChannels; ++ch) {
     memcpy(expected->channel(ch) + kPartialStart,
            kTestVectorResult[ch] + kPartialStart,
            kPartialFrames * sizeof(*expected->channel(ch)));
   }
 
   bus->Zero();
   bus->FromInterleavedPartial(
       kTestVectorInt32 + kPartialStart * bus->channels(), kPartialStart,
       kPartialFrames, sizeof(*kTestVectorInt32));
   VerifyBus(bus.get(), expected.get());
 }
 
 // Verify ToInterleaved() interleaves audio in suported formats correctly.
 TEST_F(AudioBusTest, ToInterleaved) {
-  scoped_ptr<AudioBus> bus = AudioBus::Create(
-      kTestVectorChannels, kTestVectorFrames);
+  std::unique_ptr<AudioBus> bus =
+      AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
   // Fill the bus with our test vector.
   for (int ch = 0; ch < bus->channels(); ++ch) {
     memcpy(bus->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*bus->channel(ch)));
   }
   {
     SCOPED_TRACE("uint8_t");
     uint8_t test_array[arraysize(kTestVectorUint8)];
     bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorUint8), test_array);
     ASSERT_EQ(memcmp(
@@ skipping 24 matching lines @@
   }
 }
 
 // Verify ToInterleavedPartial() interleaves audio correctly.
 TEST_F(AudioBusTest, ToInterleavedPartial) {
   // Only interleave the middle two frames in each channel.
   static const int kPartialStart = 1;
   static const int kPartialFrames = 2;
   ASSERT_LE(kPartialStart + kPartialFrames, kTestVectorFrames);
 
-  scoped_ptr<AudioBus> expected = AudioBus::Create(
-      kTestVectorChannels, kTestVectorFrames);
+  std::unique_ptr<AudioBus> expected =
+      AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
   for (int ch = 0; ch < kTestVectorChannels; ++ch) {
     memcpy(expected->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*expected->channel(ch)));
   }
 
   int16_t test_array[arraysize(kTestVectorInt16)];
   expected->ToInterleavedPartial(
       kPartialStart, kPartialFrames, sizeof(*kTestVectorInt16), test_array);
   ASSERT_EQ(memcmp(
       test_array, kTestVectorInt16 + kPartialStart * kTestVectorChannels,
       kPartialFrames * sizeof(*kTestVectorInt16) * kTestVectorChannels), 0);
 }
 
 TEST_F(AudioBusTest, Scale) {
-  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
 
   // Fill the bus with dummy data.
   static const float kFillValue = 1;
   for (int i = 0; i < bus->channels(); ++i)
     std::fill(bus->channel(i), bus->channel(i) + bus->frames(), kFillValue);
 
   // Adjust by an invalid volume and ensure volume is unchanged.
   bus->Scale(-1);
   for (int i = 0; i < bus->channels(); ++i) {
     SCOPED_TRACE("Invalid Scale");
@@ skipping 10 matching lines @@
 
   // Verify zero volume case.
   bus->Scale(0);
   for (int i = 0; i < bus->channels(); ++i) {
     SCOPED_TRACE("Zero Scale");
     VerifyValue(bus->channel(i), bus->frames(), 0);
   }
 }
 
 }  // namespace media