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

media/cdm/cdm_adapter.cc

 // Copyright 2015 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/cdm/cdm_adapter.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 315 matching lines @@
   }
 }
 
 }  // namespace
 
 // static
 void CdmAdapter::Create(
     const std::string& key_system,
     const base::FilePath& cdm_path,
     const CdmConfig& cdm_config,
-    scoped_ptr<CdmAllocator> allocator,
+    std::unique_ptr<CdmAllocator> allocator,
     const CreateCdmFileIOCB& create_cdm_file_io_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb,
     const CdmCreatedCB& cdm_created_cb) {
   DCHECK(!key_system.empty());
   DCHECK(!session_message_cb.is_null());
   DCHECK(!session_closed_cb.is_null());
   DCHECK(!legacy_session_error_cb.is_null());
   DCHECK(!session_keys_change_cb.is_null());
   DCHECK(!session_expiration_update_cb.is_null());
 
   scoped_refptr<CdmAdapter> cdm = new CdmAdapter(
       key_system, cdm_config, std::move(allocator), create_cdm_file_io_cb,
       session_message_cb, session_closed_cb, legacy_session_error_cb,
       session_keys_change_cb, session_expiration_update_cb);
 
   // |cdm| ownership passed to the promise.
-  scoped_ptr<CdmInitializedPromise> cdm_created_promise(
+  std::unique_ptr<CdmInitializedPromise> cdm_created_promise(
       new CdmInitializedPromise(cdm_created_cb, cdm));
 
   cdm->Initialize(cdm_path, std::move(cdm_created_promise));
 }
 
 CdmAdapter::CdmAdapter(
     const std::string& key_system,
     const CdmConfig& cdm_config,
-    scoped_ptr<CdmAllocator> allocator,
+    std::unique_ptr<CdmAllocator> allocator,
     const CreateCdmFileIOCB& create_cdm_file_io_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb)
     : key_system_(key_system),
       cdm_config_(cdm_config),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
@@ skipping 41 matching lines @@
 
   CdmWrapper* cdm = CdmWrapper::Create(create_cdm_func, key_system.data(),
                                        key_system.size(), GetCdmHost, this);
 
   DVLOG(1) << "CDM instance for " + key_system + (cdm ? "" : " could not be") +
                   " created.";
   return cdm;
 }
 
 void CdmAdapter::Initialize(const base::FilePath& cdm_path,
-                            scoped_ptr<media::SimpleCdmPromise> promise) {
+                            std::unique_ptr<media::SimpleCdmPromise> promise) {
   cdm_.reset(CreateCdmInstance(key_system_, cdm_path));
   if (!cdm_) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                     "Unable to create CDM.");
     return;
   }
 
   cdm_->Initialize(cdm_config_.allow_distinctive_identifier,
                    cdm_config_.allow_persistent_state);
   promise->resolve();
 }
 
-void CdmAdapter::SetServerCertificate(const std::vector<uint8_t>& certificate,
-                                      scoped_ptr<SimpleCdmPromise> promise) {
+void CdmAdapter::SetServerCertificate(
+    const std::vector<uint8_t>& certificate,
+    std::unique_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (certificate.size() < limits::kMinCertificateLength ||
       certificate.size() > limits::kMaxCertificateLength) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                     "Incorrect certificate.");
     return;
   }
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->SetServerCertificate(promise_id, certificate.data(),
                              certificate.size());
 }
 
 void CdmAdapter::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
-    scoped_ptr<NewSessionCdmPromise> promise) {
+    std::unique_ptr<NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->CreateSessionAndGenerateRequest(
       promise_id, ToCdmSessionType(session_type),
       ToCdmInitDataType(init_data_type), init_data.data(), init_data.size());
 }
 
 void CdmAdapter::LoadSession(SessionType session_type,
                              const std::string& session_id,
-                             scoped_ptr<NewSessionCdmPromise> promise) {
+                             std::unique_ptr<NewSessionCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->LoadSession(promise_id, ToCdmSessionType(session_type),
                     session_id.data(), session_id.size());
 }
 
 void CdmAdapter::UpdateSession(const std::string& session_id,
                                const std::vector<uint8_t>& response,
-                               scoped_ptr<SimpleCdmPromise> promise) {
+                               std::unique_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!session_id.empty());
   DCHECK(!response.empty());
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->UpdateSession(promise_id, session_id.data(), session_id.size(),
                       response.data(), response.size());
 }
 
 void CdmAdapter::CloseSession(const std::string& session_id,
-                              scoped_ptr<SimpleCdmPromise> promise) {
+                              std::unique_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!session_id.empty());
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->CloseSession(promise_id, session_id.data(), session_id.size());
 }
 
 void CdmAdapter::RemoveSession(const std::string& session_id,
-                               scoped_ptr<SimpleCdmPromise> promise) {
+                               std::unique_ptr<SimpleCdmPromise> promise) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!session_id.empty());
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   cdm_->RemoveSession(promise_id, session_id.data(), session_id.size());
 }
 
 CdmContext* CdmAdapter::GetCdmContext() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return this;
@@ skipping 24 matching lines @@
   NOTREACHED() << "Unexpected StreamType " << stream_type;
 }
 
 void CdmAdapter::Decrypt(StreamType stream_type,
                          const scoped_refptr<DecoderBuffer>& encrypted,
                          const DecryptCB& decrypt_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
-  scoped_ptr<DecryptedBlockImpl> decrypted_block(new DecryptedBlockImpl());
+  std::unique_ptr<DecryptedBlockImpl> decrypted_block(new DecryptedBlockImpl());
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status = cdm_->Decrypt(input_buffer, decrypted_block.get());
 
   if (status != cdm::kSuccess) {
     DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
     decrypt_cb.Run(ToMediaDecryptorStatus(status), nullptr);
     return;
   }
 
@@ skipping 79 matching lines @@
   init_cb.Run(true);
 }
 
 void CdmAdapter::DecryptAndDecodeAudio(
     const scoped_refptr<DecoderBuffer>& encrypted,
     const AudioDecodeCB& audio_decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
-  scoped_ptr<AudioFramesImpl> audio_frames(new AudioFramesImpl());
+  std::unique_ptr<AudioFramesImpl> audio_frames(new AudioFramesImpl());
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status =
       cdm_->DecryptAndDecodeSamples(input_buffer, audio_frames.get());
 
   const Decryptor::AudioFrames empty_frames;
   if (status != cdm::kSuccess) {
     DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
     audio_decode_cb.Run(ToMediaDecryptorStatus(status), empty_frames);
     return;
@@ skipping 13 matching lines @@
 
 void CdmAdapter::DecryptAndDecodeVideo(
     const scoped_refptr<DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(3) << __FUNCTION__
            << " encrypted: " << encrypted->AsHumanReadableString();
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
-  scoped_ptr<VideoFrameImpl> video_frame = allocator_->CreateCdmVideoFrame();
+  std::unique_ptr<VideoFrameImpl> video_frame =
+      allocator_->CreateCdmVideoFrame();
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status =
       cdm_->DecryptAndDecodeFrame(input_buffer, video_frame.get());
 
   if (status != cdm::kSuccess) {
     DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
     video_decode_cb.Run(ToMediaDecryptorStatus(status), nullptr);
     return;
   }
@@ skipping 207 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   std::unique_ptr<CdmFileIO> file_io = create_cdm_file_io_cb_.Run(client);
 
   // The CDM owns the returned object and must call FileIO::Close()
   // to release it.
   return file_io.release();
 }
 
 bool CdmAdapter::AudioFramesDataToAudioFrames(
-    scoped_ptr<AudioFramesImpl> audio_frames,
+    std::unique_ptr<AudioFramesImpl> audio_frames,
     Decryptor::AudioFrames* result_frames) {
   const uint8_t* data = audio_frames->FrameBuffer()->Data();
   const size_t data_size = audio_frames->FrameBuffer()->Size();
   size_t bytes_left = data_size;
   const SampleFormat sample_format =
       ToMediaSampleFormat(audio_frames->Format());
   const int audio_channel_count =
       ChannelLayoutToChannelCount(audio_channel_layout_);
   const int audio_bytes_per_frame =
       SampleFormatToBytesPerChannel(sample_format) * audio_channel_count;
@@ skipping 38 matching lines @@
     result_frames->push_back(frame);
 
     data += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace media