Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/pipeline/audio_video_pipeline_impl_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 <memory>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "chromecast/media/cma/backend/audio_decoder_default.h"
 #include "chromecast/media/cma/backend/media_pipeline_backend_default.h"
 #include "chromecast/media/cma/backend/video_decoder_default.h"
 #include "chromecast/media/cma/pipeline/av_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_impl.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_client.h"
 #include "chromecast/media/cma/test/frame_generator_for_test.h"
 #include "chromecast/media/cma/test/mock_frame_provider.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 31 matching lines @@
   void Flush(const base::Closure& flush_cb) { media_pipeline_.Flush(flush_cb); }
   void Stop() {
     media_pipeline_.Stop();
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   MediaPipelineBackendDefault* pipeline_backend() { return pipeline_backend_; }
 
  protected:
   void SetUp() override {
-    scoped_ptr<MediaPipelineBackendDefault> backend =
-        make_scoped_ptr(new MediaPipelineBackendDefault());
+    std::unique_ptr<MediaPipelineBackendDefault> backend =
+        base::WrapUnique(new MediaPipelineBackendDefault());
     pipeline_backend_ = backend.get();
     media_pipeline_.Initialize(kLoadTypeURL, std::move(backend));
 
     if (::testing::get<0>(GetParam())) {
       ::media::AudioDecoderConfig audio_config(
           ::media::kCodecMP3, ::media::kSampleFormatS16,
           ::media::CHANNEL_LAYOUT_STEREO, 44100, ::media::EmptyExtraData(),
           ::media::Unencrypted());
       AvPipelineClient client;
       client.eos_cb = base::Bind(&AudioVideoPipelineImplTest::OnEos,
@@ skipping 18 matching lines @@
       ASSERT_EQ(::media::PIPELINE_OK, status);
     }
   }
 
   base::MessageLoop message_loop_;
 
  private:
   enum Stream { STREAM_AUDIO, STREAM_VIDEO };
   DISALLOW_COPY_AND_ASSIGN(AudioVideoPipelineImplTest);
 
-  scoped_ptr<CodedFrameProvider> CreateFrameProvider() {
+  std::unique_ptr<CodedFrameProvider> CreateFrameProvider() {
     std::vector<FrameGeneratorForTest::FrameSpec> frame_specs;
     frame_specs.resize(kNumFrames);
     for (size_t k = 0; k < frame_specs.size() - 1; k++) {
       frame_specs[k].has_config = (k == 0);
       frame_specs[k].timestamp =
           base::TimeDelta::FromMicroseconds(kFrameDurationUs) * k;
       frame_specs[k].size = kFrameSize;
       frame_specs[k].has_decrypt_config = false;
     }
     frame_specs[frame_specs.size() - 1].is_eos = true;
 
-    scoped_ptr<FrameGeneratorForTest> frame_generator(
+    std::unique_ptr<FrameGeneratorForTest> frame_generator(
         new FrameGeneratorForTest(frame_specs));
     bool provider_delayed_pattern[] = {false, true};
-    scoped_ptr<MockFrameProvider> frame_provider(new MockFrameProvider());
+    std::unique_ptr<MockFrameProvider> frame_provider(new MockFrameProvider());
     frame_provider->Configure(
         std::vector<bool>(
             provider_delayed_pattern,
             provider_delayed_pattern + arraysize(provider_delayed_pattern)),
         std::move(frame_generator));
     frame_provider->SetDelayFlush(true);
     return std::move(frame_provider);
   }
 
   void OnEos(Stream stream) {
@@ skipping 82 matching lines @@
 // Test all three types of pipeline: audio-only, video-only, audio-video.
 INSTANTIATE_TEST_CASE_P(
     MediaPipelineImplTests,
     AudioVideoPipelineImplTest,
     ::testing::Values(AudioVideoTuple(true, false),   // Audio only.
                       AudioVideoTuple(false, true),   // Video only.
                       AudioVideoTuple(true, true)));  // Audio and Video.
 
 }  // namespace media
 }  // namespace chromecast