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

media/test/pipeline_integration_test.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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_keys.h"
 #include "media/base/media_switches.h"
@@ skipping 252 matching lines @@
 
     Decryptor* GetDecryptor() final { return decryptor_; }
     int GetCdmId() const final { return kInvalidCdmId; }
 
    private:
     Decryptor* decryptor_;
   };
 
   scoped_refptr<AesDecryptor> decryptor_;
   TestCdmContext cdm_context_;
-  scoped_ptr<AppBase> app_;
+  std::unique_ptr<AppBase> app_;
 };
 
 enum PromiseResult { RESOLVED, REJECTED };
 
 // Provides |kSecretKey| in response to the encrypted event.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
   KeyProvidingApp() {}
 
   void OnResolveWithSession(PromiseResult expected,
                             const std::string& session_id) {
     EXPECT_EQ(expected, RESOLVED);
     EXPECT_GT(session_id.length(), 0ul);
     current_session_id_ = session_id;
   }
 
   void OnResolve(PromiseResult expected) { EXPECT_EQ(expected, RESOLVED); }
 
   void OnReject(PromiseResult expected,
                 media::MediaKeys::Exception exception_code,
                 uint32_t system_code,
                 const std::string& error_message) {
     EXPECT_EQ(expected, REJECTED) << error_message;
   }
 
-  scoped_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
-    scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
-        base::Bind(&KeyProvidingApp::OnResolve, base::Unretained(this),
-                   expected),
-        base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
-                   expected)));
+  std::unique_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
+    std::unique_ptr<media::SimpleCdmPromise> promise(
+        new media::CdmCallbackPromise<>(
+            base::Bind(&KeyProvidingApp::OnResolve, base::Unretained(this),
+                       expected),
+            base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
+                       expected)));
     return promise;
   }
 
-  scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
+  std::unique_ptr<NewSessionCdmPromise> CreateSessionPromise(
       PromiseResult expected) {
-    scoped_ptr<media::NewSessionCdmPromise> promise(
+    std::unique_ptr<media::NewSessionCdmPromise> promise(
         new media::CdmCallbackPromise<std::string>(
             base::Bind(&KeyProvidingApp::OnResolveWithSession,
                        base::Unretained(this), expected),
             base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
                        expected)));
     return promise;
   }
 
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
@@ skipping 165 matching lines @@
 
     if (initial_append_size_ == kAppendWholeFile)
       initial_append_size_ = file_data_->data_size();
 
     DCHECK_GT(initial_append_size_, 0u);
     DCHECK_LE(initial_append_size_, file_data_->data_size());
   }
 
   virtual ~MockMediaSource() {}
 
-  scoped_ptr<Demuxer> GetDemuxer() { return std::move(owned_chunk_demuxer_); }
+  std::unique_ptr<Demuxer> GetDemuxer() {
+    return std::move(owned_chunk_demuxer_);
+  }
 
   void set_encrypted_media_init_data_cb(
       const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb) {
     encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   }
 
   void Seek(base::TimeDelta seek_time,
             size_t new_position,
             size_t seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
@@ skipping 112 matching lines @@
     DCHECK(!init_data.empty());
     CHECK(!encrypted_media_init_data_cb_.is_null());
     encrypted_media_init_data_cb_.Run(init_data_type, init_data);
   }
 
   base::TimeDelta last_timestamp_offset() const {
     return last_timestamp_offset_;
   }
 
   // A workaround for gtest mocks not allowing moving scoped_ptrs.
-  void InitSegmentReceivedWrapper(scoped_ptr<MediaTracks> tracks) {
+  void InitSegmentReceivedWrapper(std::unique_ptr<MediaTracks> tracks) {
     InitSegmentReceived(tracks);
   }
 
-  MOCK_METHOD1(InitSegmentReceived, void(scoped_ptr<MediaTracks>&));
+  MOCK_METHOD1(InitSegmentReceived, void(std::unique_ptr<MediaTracks>&));
 
  private:
   scoped_refptr<DecoderBuffer> file_data_;
   size_t current_position_;
   size_t initial_append_size_;
   std::string mimetype_;
   ChunkDemuxer* chunk_demuxer_;
-  scoped_ptr<Demuxer> owned_chunk_demuxer_;
+  std::unique_ptr<Demuxer> owned_chunk_demuxer_;
   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
   base::TimeDelta last_timestamp_offset_;
 };
 
 #if defined(MOJO_RENDERER)
 class PipelineIntegrationTestHost : public shell::test::ApplicationTestBase,
                                     public PipelineIntegrationTestBase {
  public:
   bool ShouldCreateDefaultRunLoop() override { return false; }
 
   void SetUp() override {
     ApplicationTestBase::SetUp();
     InitializeMediaLibrary();
   }
 
  protected:
-  scoped_ptr<Renderer> CreateRenderer() override {
+  std::unique_ptr<Renderer> CreateRenderer() override {
     connector()->ConnectToInterface("mojo:media", &media_service_factory_);
 
     interfaces::RendererPtr mojo_renderer;
     media_service_factory_->CreateRenderer(mojo::GetProxy(&mojo_renderer));
 
-    return make_scoped_ptr(new MojoRendererImpl(message_loop_.task_runner(),
-                                                std::move(mojo_renderer)));
+    return base::WrapUnique(new MojoRendererImpl(message_loop_.task_runner(),
+                                                 std::move(mojo_renderer)));
   }
 
  private:
   interfaces::ServiceFactoryPtr media_service_factory_;
 };
 #else
 class PipelineIntegrationTestHost : public testing::Test,
                                     public PipelineIntegrationTestBase {};
 #endif  // defined(MOJO_RENDERER)
 
@@ skipping 1478 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media