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

media/base/audio_fifo_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.
 
 // TODO(henrika): add test which included |start_frame| in Consume() call.
 
+#include <memory>
+
 #include "base/macros.h"
 #include "media/base/audio_fifo.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 class AudioFifoTest : public testing::Test {
  public:
   AudioFifoTest() {}
   ~AudioFifoTest() override {}
@@ skipping 15 matching lines @@
   EXPECT_EQ(fifo.frames(), 0);
 }
 
 // Pushes audio bus objects to a FIFO and fill it up to different degrees.
 TEST_F(AudioFifoTest, Push) {
   static const int kChannels = 2;
   static const int kMaxFrameCount = 128;
   AudioFifo fifo(kChannels, kMaxFrameCount);
   {
     SCOPED_TRACE("Push 50%");
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount / 2);
+    std::unique_ptr<AudioBus> bus =
+        AudioBus::Create(kChannels, kMaxFrameCount / 2);
     EXPECT_EQ(fifo.frames(), 0);
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), bus->frames());
     fifo.Clear();
   }
   {
     SCOPED_TRACE("Push 100%");
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
+    std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
     EXPECT_EQ(fifo.frames(), 0);
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), bus->frames());
     fifo.Clear();
   }
 }
 
 // Consumes audio bus objects from a FIFO and empty it to different degrees.
 TEST_F(AudioFifoTest, Consume) {
   static const int kChannels = 2;
   static const int kMaxFrameCount = 128;
   AudioFifo fifo(kChannels, kMaxFrameCount);
   {
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
+    std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), kMaxFrameCount);
   }
   {
     SCOPED_TRACE("Consume 50%");
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount / 2);
+    std::unique_ptr<AudioBus> bus =
+        AudioBus::Create(kChannels, kMaxFrameCount / 2);
     fifo.Consume(bus.get(), 0, bus->frames());
     EXPECT_TRUE(fifo.frames() == bus->frames());
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), kMaxFrameCount);
   }
   {
     SCOPED_TRACE("Consume 100%");
-    scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
+    std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kMaxFrameCount);
     fifo.Consume(bus.get(), 0, bus->frames());
     EXPECT_EQ(fifo.frames(), 0);
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), kMaxFrameCount);
   }
 }
 
 // Verify that the frames() method of the FIFO works as intended while
 // appending and removing audio bus elements to/from the FIFO.
 TEST_F(AudioFifoTest, FramesInFifo) {
   static const int kChannels = 2;
   static const int kMaxFrameCount = 64;
   AudioFifo fifo(kChannels, kMaxFrameCount);
 
   // Fill up the FIFO and verify that the size grows as it should while adding
   // one audio frame each time.
-  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, 1);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, 1);
   int n = 0;
   while (fifo.frames() < kMaxFrameCount) {
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), ++n);
   }
   EXPECT_EQ(fifo.frames(), kMaxFrameCount);
 
   // Empty the FIFO and verify that the size decreases as it should.
   // Reduce the size of the FIFO by one frame each time.
   while (fifo.frames() > 0) {
     fifo.Consume(bus.get(), 0, bus->frames());
     EXPECT_EQ(fifo.frames(), --n);
   }
   EXPECT_EQ(fifo.frames(), 0);
 
   // Verify that a steady-state size of #frames in the FIFO is maintained
   // during a sequence of Push/Consume calls which involves wrapping. We ensure
   // wrapping by selecting a buffer size which does divides the FIFO size
   // with a remainder of one.
-  scoped_ptr<AudioBus> bus2 =
+  std::unique_ptr<AudioBus> bus2 =
       AudioBus::Create(kChannels, (kMaxFrameCount / 4) - 1);
   const int frames_in_fifo = bus2->frames();
   fifo.Push(bus2.get());
   EXPECT_EQ(fifo.frames(), frames_in_fifo);
   for (int n = 0; n < kMaxFrameCount; ++n) {
     fifo.Push(bus2.get());
     fifo.Consume(bus2.get(), 0, frames_in_fifo);
     EXPECT_EQ(fifo.frames(), frames_in_fifo);
   }
 }
 
 // Perform a sequence of Push/Consume calls and verify that the data written
 // to the FIFO is correctly retrieved, i.e., that the order is correct and the
 // values are correct.
 TEST_F(AudioFifoTest, VerifyDataValues) {
   static const int kChannels = 2;
   static const int kFrameCount = 2;
   static const int kFifoFrameCount = 5 * kFrameCount;
 
   AudioFifo fifo(kChannels, kFifoFrameCount);
-  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
   EXPECT_EQ(fifo.frames(), 0);
   EXPECT_EQ(bus->frames(), kFrameCount);
 
   // Start by filling up the FIFO with audio frames. The first audio frame
   // will contain all 1's, the second all 2's etc. All channels contain the
   // same value.
   int value = 1;
   while (fifo.frames() < kFifoFrameCount) {
     for (int j = 0; j < bus->channels(); ++j)
       std::fill(bus->channel(j), bus->channel(j) + bus->frames(), value);
@@ skipping 39 matching lines @@
       VerifyValue(bus->channel(j), bus->channels(), value);
       std::fill(bus->channel(j), bus->channel(j) + bus->frames(), value + 1);
     }
     fifo.Push(bus.get());
     EXPECT_EQ(fifo.frames(), bus->frames());
     ++value;
   }
 }
 
 }  // namespace media