Convert //media/cast from scoped_ptr to std::unique_ptr

media/cast/sender/audio_encoder_unittest.cc

 // Copyright 2014 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 "media/cast/sender/audio_encoder.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <sstream>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "media/base/audio_bus.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/media.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/common/rtp_time.h"
-#include "media/cast/sender/audio_encoder.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 static const int kNumChannels = 2;
 
 namespace {
 
 class TestEncodedAudioFrameReceiver {
  public:
   TestEncodedAudioFrameReceiver() : frames_received_(0) {}
   virtual ~TestEncodedAudioFrameReceiver() {}
 
   int frames_received() const { return frames_received_; }
 
   void SetCaptureTimeBounds(const base::TimeTicks& lower_bound,
                             const base::TimeTicks& upper_bound) {
     lower_bound_ = lower_bound;
     upper_bound_ = upper_bound;
   }
 
   void SetSamplesPerFrame(int samples_per_frame) {
     samples_per_frame_ = samples_per_frame;
   }
 
-  void FrameEncoded(scoped_ptr<SenderEncodedFrame> encoded_frame,
+  void FrameEncoded(std::unique_ptr<SenderEncodedFrame> encoded_frame,
                     int samples_skipped) {
     EXPECT_EQ(encoded_frame->dependency, EncodedFrame::KEY);
     EXPECT_EQ(static_cast<uint8_t>(frames_received_ & 0xff),
               encoded_frame->frame_id);
     EXPECT_EQ(encoded_frame->frame_id, encoded_frame->referenced_frame_id);
     // RTP timestamps should be monotonically increasing and integer multiples
     // of the fixed frame size.
     EXPECT_LE(rtp_lower_bound_, encoded_frame->rtp_timestamp);
     rtp_lower_bound_ = encoded_frame->rtp_timestamp;
     EXPECT_EQ(RtpTimeDelta(), (encoded_frame->rtp_timestamp - RtpTimeTicks()) %
@@ skipping 44 matching lines @@
  public:
   AudioEncoderTest() {
     InitializeMediaLibrary();
     testing_clock_ = new base::SimpleTestTickClock();
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
   }
 
   void SetUp() final {
     task_runner_ = new FakeSingleThreadTaskRunner(testing_clock_);
     cast_environment_ =
-        new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_),
+        new CastEnvironment(std::unique_ptr<base::TickClock>(testing_clock_),
                             task_runner_, task_runner_, task_runner_);
   }
 
   virtual ~AudioEncoderTest() {}
 
   void RunTestForCodec(Codec codec) {
     const TestScenario& scenario = GetParam();
     SCOPED_TRACE(::testing::Message() << "Durations: " << scenario.ToString());
 
     CreateObjectsForCodec(codec);
@@ skipping 39 matching lines @@
         kDefaultAudioEncoderBitrate,
         codec,
         base::Bind(&TestEncodedAudioFrameReceiver::FrameEncoded,
                    base::Unretained(receiver_.get()))));
 
     receiver_->SetSamplesPerFrame(audio_encoder_->GetSamplesPerFrame());
   }
 
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
-  scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
-  scoped_ptr<TestEncodedAudioFrameReceiver> receiver_;
-  scoped_ptr<AudioEncoder> audio_encoder_;
+  std::unique_ptr<TestAudioBusFactory> audio_bus_factory_;
+  std::unique_ptr<TestEncodedAudioFrameReceiver> receiver_;
+  std::unique_ptr<AudioEncoder> audio_encoder_;
   scoped_refptr<CastEnvironment> cast_environment_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioEncoderTest);
 };
 
 TEST_P(AudioEncoderTest, EncodeOpus) {
   RunTestForCodec(CODEC_AUDIO_OPUS);
 }
 
 TEST_P(AudioEncoderTest, EncodePcm16) {
@@ skipping 59 matching lines @@
         TestScenario(kManyCalls_Mixed2, arraysize(kManyCalls_Mixed2)),
         TestScenario(kManyCalls_Mixed3, arraysize(kManyCalls_Mixed3)),
         TestScenario(kManyCalls_Mixed4, arraysize(kManyCalls_Mixed4)),
         TestScenario(kManyCalls_Mixed5, arraysize(kManyCalls_Mixed5)),
         TestScenario(kOneBigUnderrun, arraysize(kOneBigUnderrun)),
         TestScenario(kTwoBigUnderruns, arraysize(kTwoBigUnderruns)),
         TestScenario(kMixedUnderruns, arraysize(kMixedUnderruns))));
 
 }  // namespace cast
 }  // namespace media